#include <FilterBodyFittedVelocity.h>

Inheritance diagram for Nektar::SolverUtils::FilterBodyFittedVelocity:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterBodyFittedVelocity (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const ParamMap &pParams)

SOLVER_UTILS_EXPORT	~FilterBodyFittedVelocity () override

Public Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
SOLVER_UTILS_EXPORT	FilterFieldConvert (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const ParamMap &pParams)

SOLVER_UTILS_EXPORT	~FilterFieldConvert () override

Public Member Functions inherited from Nektar::SolverUtils::Filter
SOLVER_UTILS_EXPORT	Filter (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)

virtual SOLVER_UTILS_EXPORT	~Filter ()

SOLVER_UTILS_EXPORT void	Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT bool	IsTimeDependent ()

Static Public Member Functions
static FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)
	Creates an instance of this class. More...

Static Public Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
static FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of the class. More...

Static Public Attributes inherited from Nektar::SolverUtils::FilterFieldConvert
static std::string	className
	Name of the class. More...

Protected Types
enum	FilterType { eOriginal , eMax , eMin }

enum	ProblemType { eCompressible , eIncompressible , eOthers }

Protected Member Functions
void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

void	v_FillVariablesName (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields) override

void	v_ProcessSample (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, const NekDouble &time) override

void	v_PrepareOutput (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

NekDouble	v_GetScale () override

std::string	v_GetFileSuffix () override

Protected Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
SOLVER_UTILS_EXPORT void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

virtual SOLVER_UTILS_EXPORT void	v_FillVariablesName (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

SOLVER_UTILS_EXPORT void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

SOLVER_UTILS_EXPORT void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

virtual SOLVER_UTILS_EXPORT void	v_ProcessSample (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_PrepareOutput (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT NekDouble	v_GetScale ()

virtual SOLVER_UTILS_EXPORT std::string	v_GetFileSuffix ()

void	OutputField (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, int dump=-1)

SOLVER_UTILS_EXPORT bool	v_IsTimeDependent () override

void	CreateModules (std::vector< std::string > &modcmds)

void	CreateFields (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

void	CheckModules (std::vector< ModuleSharedPtr > &modules)

virtual void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual bool	v_IsTimeDependent ()=0

Protected Attributes
std::string	m_bodyFittedCooriateFile

FilterType	m_filterType

ProblemType	m_problemType

unsigned int	m_spaceDim

unsigned int	m_nFields

unsigned int	m_nAddFields

unsigned int	m_nVars

std::vector< std::string >	m_bfsVars

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_bfcsDir

std::vector< Array< OneD, NekDouble > >	m_curFieldsVels_Car

std::vector< Array< OneD, NekDouble > >	m_curFieldsVels

std::vector< Array< OneD, NekDouble > >	m_outFieldsVels

std::vector< Array< OneD, NekDouble > >	m_curFieldsThermalVars

std::vector< Array< OneD, NekDouble > >	m_outFieldsThermalVars

Protected Attributes inherited from Nektar::SolverUtils::FilterFieldConvert
unsigned int	m_numSamples

unsigned int	m_outputFrequency

unsigned int	m_sampleFrequency

std::string	m_outputFile

std::string	m_restartFile

unsigned int	m_index

unsigned int	m_outputIndex

bool	m_phaseSample

NekDouble	m_phaseSamplePeriod

NekDouble	m_phaseSamplePhase

NekDouble	m_phaseTolerance

NekDouble	m_dt

std::vector< ModuleSharedPtr >	m_modules

LibUtilities::FieldMetaDataMap	m_fieldMetaData

std::vector< Array< OneD, NekDouble > >	m_outFields

std::vector< std::string >	m_variables

FieldSharedPtr	m_f

po::variables_map	m_vm

Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session

const std::weak_ptr< EquationSystem >	m_equ

Private Attributes
bool	m_initialized

Friends
class	MemoryManager< FilterBodyFittedVelocity >

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Filter
typedef std::map< std::string, std::string >	ParamMap

Detailed Description

Definition at line 44 of file FilterBodyFittedVelocity.h.

Member Enumeration Documentation

◆ FilterType

enum Nektar::SolverUtils::FilterBodyFittedVelocity::FilterType

protected

Enumerator
eOriginal
eMax
eMin

Definition at line 72 of file FilterBodyFittedVelocity.h.

    {
        eOriginal,
        eMax,
        eMin
    };

◆ ProblemType

enum Nektar::SolverUtils::FilterBodyFittedVelocity::ProblemType

protected

Enumerator
eCompressible
eIncompressible
eOthers

Definition at line 78 of file FilterBodyFittedVelocity.h.

    {
        eCompressible,
        eIncompressible,
        eOthers
    };

Constructor & Destructor Documentation

◆ FilterBodyFittedVelocity()

Nektar::SolverUtils::FilterBodyFittedVelocity::FilterBodyFittedVelocity	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation,
		const ParamMap &	pParams
	)

Definition at line 54 of file FilterBodyFittedVelocity.cpp.

    : FilterFieldConvert(pSession, pEquation, pParams)
{
    // Load sampling frequency
    auto it = pParams.find("SampleFrequency");
    if (it == pParams.end())
    {
        m_sampleFrequency = 1;
    }
    else
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_sampleFrequency = round(equ.Evaluate());
    }
 
    // Load flag for filter type
    it = pParams.find("OriginalOrMaxOrMin");
    if (it == pParams.end())
    {
        m_filterType = eOriginal;
    }
    else
    {
        std::string sOptionType = it->second.c_str();
        if (boost::iequals(sOptionType, "maximum") ||
            boost::iequals(sOptionType, "max"))
        {
            m_filterType = eMax;
        }
        else if (boost::iequals(sOptionType, "minumun") ||
                 boost::iequals(sOptionType, "min"))
        {
            m_filterType = eMin;
        }
        else if (boost::iequals(sOptionType, "original"))
        {
            m_filterType = eOriginal;
        }
        else
        {
            WARNINGL0(false, "Detailed filter type is not found, use original");
            m_filterType = eOriginal;
        }
    }
 
    // Load bodyFittedCoordinate from a file generated by FieldConvert -m
    // bodyFittedVelocity
    it = pParams.find("BodyFittedCoordinateFile");
    ASSERTL0(it->second.length() > 0,
             "Missing parameter 'BodyFittedCoordinateFile'.");
 
    if (it->second.find_last_of('.') != std::string::npos)
    {
 
        m_bodyFittedCooriateFile = it->second;
    }
    else
    {
        std::stringstream outname;
        outname << it->second << ".fld";
        m_bodyFittedCooriateFile = outname.str();
    }
 
    m_initialized = m_restartFile != "";
}

References ASSERTL0, eMax, eMin, eOriginal, Nektar::LibUtilities::Equation::Evaluate(), m_bodyFittedCooriateFile, m_filterType, m_initialized, Nektar::SolverUtils::FilterFieldConvert::m_restartFile, Nektar::SolverUtils::FilterFieldConvert::m_sampleFrequency, Nektar::SolverUtils::Filter::m_session, and WARNINGL0.

◆ ~FilterBodyFittedVelocity()

Nektar::SolverUtils::FilterBodyFittedVelocity::~FilterBodyFittedVelocity ( )

override

Definition at line 122 of file FilterBodyFittedVelocity.cpp.

123{

124}

Member Function Documentation

◆ create()

static FilterSharedPtr Nektar::SolverUtils::FilterBodyFittedVelocity::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation,
		const std::map< std::string, std::string > &	pParams
	)

inlinestatic

Creates an instance of this class.

Definition at line 50 of file FilterBodyFittedVelocity.h.

    {
        FilterSharedPtr p =
            MemoryManager<FilterBodyFittedVelocity>::AllocateSharedPtr(
                pSession, pEquation, pParams);
        return p;
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ v_FillVariablesName()

void Nektar::SolverUtils::FilterBodyFittedVelocity::v_FillVariablesName ( const Array< OneD, const MultiRegions::ExpListSharedPtr > & pFields )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 275 of file FilterBodyFittedVelocity.cpp.

{
    // Fill in the var names using the routine in base class
    FilterFieldConvert::v_FillVariablesName(pFields);
 
    // Check type of problem
    std::vector<std::string> varNames =
        pFields[0]->GetSession()->GetVariables();
    if (boost::iequals(varNames[0], "u") && boost::iequals(varNames[1], "v"))
    {
        m_problemType = eIncompressible;
        m_spaceDim    = pFields.size() - 1;
    }
    else if (boost::iequals(varNames[0], "rho") &&
             boost::iequals(varNames[1], "rhou"))
    {
        m_problemType = eCompressible;
        m_spaceDim    = pFields.size() - 2;
    }
    else
    {
        WARNINGL0(false, "Problem type is not claear. Please check");
        m_problemType = eOthers;
        m_spaceDim    = 2;
    }
 
    m_nVars      = m_variables.size(); // Include extra vars
    m_nFields    = pFields.size();     // Conservative vars for cfs
    m_nAddFields = 3;
 
    // Fill in the body-fitted velocity names
    // bfc represents body-fitted coordinate
    m_variables.push_back("distanceToWall");
    m_variables.push_back("u_bfc");
    m_variables.push_back("v_bfc");
    if (m_spaceDim == 3)
    {
        m_variables.push_back("w_bfc");
        ++m_nAddFields;
    }
    else if (m_spaceDim != 2)
    {
        ASSERTL0(false, "Unsupported dimension");
    }
}

References ASSERTL0, eCompressible, eIncompressible, eOthers, m_nAddFields, m_nFields, m_nVars, m_problemType, m_spaceDim, Nektar::SolverUtils::FilterFieldConvert::m_variables, Nektar::SolverUtils::FilterFieldConvert::v_FillVariablesName(), and WARNINGL0.

◆ v_GetFileSuffix()

std::string Nektar::SolverUtils::FilterBodyFittedVelocity::v_GetFileSuffix ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 118 of file FilterBodyFittedVelocity.h.

    {
        if (m_filterType == eMax)
        {
            return "_max";
        }
        else if (m_filterType == eMin)
        {
            return "_min";
        }
        else
        {
            return "_original";
        }
    }

References eMax, eMin, and m_filterType.

◆ v_GetScale()

NekDouble Nektar::SolverUtils::FilterBodyFittedVelocity::v_GetScale ( )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 494 of file FilterBodyFittedVelocity.cpp.

{
    return 1.0;
}

◆ v_Initialise()

void Nektar::SolverUtils::FilterBodyFittedVelocity::v_Initialise	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 126 of file FilterBodyFittedVelocity.cpp.

{
    // Initialise output arrays
    FilterFieldConvert::v_Initialise(pFields, time);
 
    // Generate the body-fitted coordinate system and distance field
    // bfcsDir[i][j][k]
    //   i - dir vec:   0-main tangential, 1-normal, (2-minor tangential)
    //   j - component: 0-x, 1-y, (2-z)
    //   k - point id
    const int npoints = pFields[0]->GetTotPoints();
    m_bfcsDir = Array<OneD, Array<OneD, Array<OneD, NekDouble>>>(m_spaceDim);
    for (int i = 0; i < m_spaceDim; ++i)
    {
        m_bfcsDir[i] = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
        for (int j = 0; j < m_spaceDim; ++j)
        {
            m_bfcsDir[i][j] = Array<OneD, NekDouble>(npoints);
        }
    }
 
    // Initialize the body fitted coordinate in the file
    // m_bfsVars holds the var names for the coordinate system and will be
    // used to find corresponding field to load from the input file.
    // Ref: FilterFieldConvert.cpp (v_Initialise) & ProcessInterpField.cpp
    // (Process)
    m_bfsVars.resize(m_spaceDim * m_spaceDim); // 4 or 9
    if (m_spaceDim == 2)
    {
        m_bfsVars[0] = "bfc_dir0_x";
        m_bfsVars[1] = "bfc_dir0_y";
        m_bfsVars[2] = "bfc_dir1_x";
        m_bfsVars[3] = "bfc_dir1_y";
    }
    else
    {
        m_bfsVars[0] = "bfc_dir0_x";
        m_bfsVars[1] = "bfc_dir0_y";
        m_bfsVars[2] = "bfc_dir0_z";
        m_bfsVars[3] = "bfc_dir1_x";
        m_bfsVars[4] = "bfc_dir1_y";
        m_bfsVars[5] = "bfc_dir1_z";
        m_bfsVars[6] = "bfc_dir2_x";
        m_bfsVars[7] = "bfc_dir2_y";
        m_bfsVars[8] = "bfc_dir2_z";
    }
 
    // Load file
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> fieldDef;
    std::vector<std::vector<NekDouble>> fieldData;
    LibUtilities::FieldMetaDataMap fieldMetaData;
    LibUtilities::FieldIOSharedPtr fld = LibUtilities::FieldIO::CreateForFile(
        m_session, m_bodyFittedCooriateFile);
    fld->Import(m_bodyFittedCooriateFile, fieldDef, fieldData, fieldMetaData);
 
    // Get a tmp array to hold the coeffs from the input file
    Array<OneD, NekDouble> tmp_coeffs;
    tmp_coeffs = Array<OneD, NekDouble>(pFields[0]->GetNcoeffs(), 0.0);
 
    // Extract data and convert to physical space
    for (int k = 0; k < m_bfsVars.size(); ++k)
    {
        // In the fieldDef, for example fieldDef[0] is the quad and
        // fieldDef[1] is the tri region
        // Each of fieldDef[i] contains all the fields we expected in an fld
        for (int i = 0; i < fieldData.size(); ++i)
        {
            pFields[0]->ExtractDataToCoeffs(fieldDef[i], fieldData[i],
                                            m_bfsVars[k], tmp_coeffs);
        }
 
        // Bwd transorm the data and put them into m_bfcsDir[][]
        int ii, jj;
        jj = k % m_spaceDim;
        ii = k / m_spaceDim;
 
        pFields[0]->BwdTrans(tmp_coeffs, m_bfcsDir[ii][jj]);
    }
 
    // Allocate storage
    m_curFieldsVels_Car.resize(m_spaceDim);
    m_curFieldsVels.resize(m_spaceDim); // m_spaceDim = m_nAddFields-1
    m_outFieldsVels.resize(m_spaceDim);
 
    for (int n = 0; n < m_spaceDim; ++n)
    {
        m_curFieldsVels_Car[n] = Array<OneD, NekDouble>(npoints, 0.0);
        m_curFieldsVels[n]     = Array<OneD, NekDouble>(npoints, 0.0);
        m_outFieldsVels[n]     = Array<OneD, NekDouble>(npoints, 0.0);
    }
 
    // Allocate storage for rho,p,T
    if (m_problemType == eCompressible)
    {
        m_curFieldsThermalVars.resize(3);
        m_outFieldsThermalVars.resize(3);
 
        for (int n = 0; n < 3; ++n)
        {
            m_curFieldsThermalVars[n] = Array<OneD, NekDouble>(npoints, 0.0);
            m_outFieldsThermalVars[n] = Array<OneD, NekDouble>(npoints, 0.0);
        }
    }
 
    // m_outFields contains the initialization values
    // 2d: rho,rhou,rhov,E,u,v,p,T,s,a,Mach,Sensor,distanceToWall,u_bfc,v_bfc
    if (m_initialized)
    {
        for (int n = 0; n < m_spaceDim; ++n)
        {
            pFields[0]->BwdTrans(m_outFields[m_nVars + 1 + n],
                                 m_outFieldsVels[n]);
            if (pFields[0]->GetWaveSpace())
            {
                pFields[0]->HomogeneousBwdTrans(npoints, m_outFieldsVels[n],
                                                m_outFieldsVels[n]);
            }
        }
 
        if (m_problemType == eCompressible)
        {
            // For cfs, initialize thermal vars
            // shift_thermal for [rho, p, T] in m_outFields
            int shift_thermal[3] = {0, m_spaceDim * 2 + 2, m_spaceDim * 2 + 3};
 
            for (int n = 0; n < 3; ++n)
            {
                pFields[0]->BwdTrans(m_outFields[shift_thermal[n]],
                                     m_outFieldsThermalVars[n]);
                if (pFields[0]->GetWaveSpace())
                {
                    pFields[0]->HomogeneousBwdTrans(npoints,
                                                    m_outFieldsThermalVars[n],
                                                    m_outFieldsThermalVars[n]);
                }
            }
        }
    }
    else
    {
        ASSERTL0(false, "Restart file is expectd. It can be generated by \
                         FieldConvert in serial. For example: \
                         FieldConvert -m bodyFittedVelocity:bnd=0:bfcOut=1 \
                         mesh.xml session.xml baseflow.fld bfvFile.fld");
    }
}

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), eCompressible, m_bfcsDir, m_bfsVars, m_bodyFittedCooriateFile, m_curFieldsThermalVars, m_curFieldsVels, m_curFieldsVels_Car, m_initialized, m_nVars, Nektar::SolverUtils::FilterFieldConvert::m_outFields, m_outFieldsThermalVars, m_outFieldsVels, m_problemType, Nektar::SolverUtils::Filter::m_session, m_spaceDim, and Nektar::SolverUtils::FilterFieldConvert::v_Initialise().

◆ v_PrepareOutput()

void Nektar::SolverUtils::FilterBodyFittedVelocity::v_PrepareOutput	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 486 of file FilterBodyFittedVelocity.cpp.

{
    m_fieldMetaData["NumberOfFieldDumps"] = std::to_string(m_numSamples);
}

References Nektar::SolverUtils::FilterFieldConvert::m_fieldMetaData, and Nektar::SolverUtils::FilterFieldConvert::m_numSamples.

◆ v_ProcessSample()

void Nektar::SolverUtils::FilterBodyFittedVelocity::v_ProcessSample	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		const NekDouble &	time
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 338 of file FilterBodyFittedVelocity.cpp.

{
    // Use shift_vel to get the current u,v,w in Cartesian coordinate
    // cfs_2D:
    // rho,rhou,rhov,E,u,v,p,T,s,a,Mach,Sensor,distanceToWall,u_bfc,v_bfc
    // inc_2D: u,v,p
    int shift_vel = (m_problemType == eCompressible) ? (m_spaceDim + 2) : 0;
 
    // Get current u,v,w in Cartesian coordinate
    for (int n = 0; n < m_spaceDim; ++n)
    {
        pFields[0]->BwdTrans(fieldcoeffs[shift_vel + n],
                             m_curFieldsVels_Car[n]);
        if (pFields[0]->GetWaveSpace())
        {
            pFields[0]->HomogeneousBwdTrans(pFields[0]->GetNpoints(),
                                            m_curFieldsVels_Car[n],
                                            m_curFieldsVels_Car[n]);
        }
    }
 
    // Project the velocity into the body-fitted coordinate system
    int npoints = pFields[0]->GetTotPoints();
    Array<OneD, NekDouble> vel_tmp(npoints);
 
    for (int i = 0; i < m_spaceDim; ++i) // loop for bfc velocity
    {
        Vmath::Zero(npoints, m_curFieldsVels[i], 1);
 
        for (int j = 0; j < m_spaceDim; ++j)
        {
            Vmath::Vmul(npoints, m_curFieldsVels_Car[j], 1, m_bfcsDir[i][j], 1,
                        vel_tmp, 1);
            Vmath::Vadd(npoints, vel_tmp, 1, m_curFieldsVels[i], 1,
                        m_curFieldsVels[i], 1);
        }
    }
 
    // Get max/min/original for the u/v/w_bfc field
    for (int n = 0; n < m_spaceDim; ++n)
    {
        size_t length = m_outFieldsVels[n].size();
 
        if (m_filterType == eMax)
        {
            // Compute max
            for (int i = 0; i < length; ++i)
            {
                if (m_curFieldsVels[n][i] > m_outFieldsVels[n][i])
                {
                    m_outFieldsVels[n][i] = m_curFieldsVels[n][i];
                }
            }
        }
        else if (m_filterType == eMin)
        {
            // Compute min
            for (int i = 0; i < length; ++i)
            {
                if (m_curFieldsVels[n][i] < m_outFieldsVels[n][i])
                {
                    m_outFieldsVels[n][i] = m_curFieldsVels[n][i];
                }
            }
        }
        else
        {
            // Original field
            m_outFieldsVels[n] = m_curFieldsVels[n];
        }
    }
 
    // Forward transform and put into m_outFields
    for (int n = 0; n < m_spaceDim; ++n)
    {
        pFields[0]->FwdTransLocalElmt(m_outFieldsVels[n],
                                      m_outFields[m_nVars + 1 + n]);
    }
 
    // Process the thermal variables for compressible flows
    if (m_problemType == eCompressible)
    {
        // Get current rho,p,T fields
        // shift_thermal for [rho, p, T] in fieldcoeffs
        int shift_thermal[3] = {0, m_spaceDim * 2 + 2, m_spaceDim * 2 + 3};
 
        for (int n = 0; n < 3; ++n)
        {
            pFields[0]->BwdTrans(fieldcoeffs[shift_thermal[n]],
                                 m_curFieldsThermalVars[n]);
            if (pFields[0]->GetWaveSpace())
            {
                pFields[0]->HomogeneousBwdTrans(pFields[0]->GetNpoints(),
                                                m_curFieldsThermalVars[n],
                                                m_curFieldsThermalVars[n]);
            }
        }
 
        // Get max/min/original for the rho/p/T fields
        for (int n = 0; n < 3; ++n)
        {
            size_t length = m_outFieldsThermalVars[n].size();
 
            if (m_filterType == eMax)
            {
                // Compute max
                for (int i = 0; i < length; ++i)
                {
                    if (m_curFieldsThermalVars[n][i] >
                        m_outFieldsThermalVars[n][i])
                    {
                        m_outFieldsThermalVars[n][i] =
                            m_curFieldsThermalVars[n][i];
                    }
                }
            }
            else if (m_filterType == eMin)
            {
                // Compute min
                for (int i = 0; i < length; ++i)
                {
                    if (m_curFieldsThermalVars[n][i] <
                        m_outFieldsThermalVars[n][i])
                    {
                        m_outFieldsThermalVars[n][i] =
                            m_curFieldsThermalVars[n][i];
                    }
                }
            }
            else
            {
                // Original field
                m_outFieldsThermalVars[n] = m_curFieldsThermalVars[n];
            }
        }
 
        // Forward transform and put into m_outFields
        for (int n = 0; n < 3; ++n)
        {
            pFields[0]->FwdTransLocalElmt(m_outFieldsThermalVars[n],
                                          m_outFields[shift_thermal[n]]);
        }
    }
}

References eCompressible, eMax, eMin, m_bfcsDir, m_curFieldsThermalVars, m_curFieldsVels, m_curFieldsVels_Car, m_filterType, m_nVars, Nektar::SolverUtils::FilterFieldConvert::m_outFields, m_outFieldsThermalVars, m_outFieldsVels, m_problemType, m_spaceDim, Vmath::Vadd(), Vmath::Vmul(), and Vmath::Zero().

Friends And Related Function Documentation

◆ MemoryManager< FilterBodyFittedVelocity >

friend class MemoryManager< FilterBodyFittedVelocity >

friend

Definition at line 1 of file FilterBodyFittedVelocity.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::FilterBodyFittedVelocity::className

static

Initial value:

=
    GetFilterFactory().RegisterCreatorFunction(
        "BodyFittedVelocity", FilterBodyFittedVelocity::create)

Name of the class.

Definition at line 62 of file FilterBodyFittedVelocity.h.

◆ m_bfcsDir

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::FilterBodyFittedVelocity::m_bfcsDir

protected

Definition at line 95 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_bfsVars

std::vector<std::string> Nektar::SolverUtils::FilterBodyFittedVelocity::m_bfsVars

protected

Definition at line 94 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise().

◆ m_bodyFittedCooriateFile

std::string Nektar::SolverUtils::FilterBodyFittedVelocity::m_bodyFittedCooriateFile

protected

Definition at line 85 of file FilterBodyFittedVelocity.h.

Referenced by FilterBodyFittedVelocity(), and v_Initialise().

◆ m_curFieldsThermalVars

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterBodyFittedVelocity::m_curFieldsThermalVars

protected

Definition at line 101 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_curFieldsVels

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterBodyFittedVelocity::m_curFieldsVels

protected

Definition at line 98 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_curFieldsVels_Car

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterBodyFittedVelocity::m_curFieldsVels_Car

protected

Definition at line 97 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_filterType

FilterType Nektar::SolverUtils::FilterBodyFittedVelocity::m_filterType

protected

Definition at line 87 of file FilterBodyFittedVelocity.h.

Referenced by FilterBodyFittedVelocity(), v_GetFileSuffix(), and v_ProcessSample().

◆ m_initialized

bool Nektar::SolverUtils::FilterBodyFittedVelocity::m_initialized

private

Definition at line 135 of file FilterBodyFittedVelocity.h.

Referenced by FilterBodyFittedVelocity(), and v_Initialise().

◆ m_nAddFields

unsigned int Nektar::SolverUtils::FilterBodyFittedVelocity::m_nAddFields

protected

Definition at line 91 of file FilterBodyFittedVelocity.h.

Referenced by v_FillVariablesName().

◆ m_nFields

unsigned int Nektar::SolverUtils::FilterBodyFittedVelocity::m_nFields

protected

Definition at line 90 of file FilterBodyFittedVelocity.h.

Referenced by v_FillVariablesName().

◆ m_nVars

unsigned int Nektar::SolverUtils::FilterBodyFittedVelocity::m_nVars

protected

Definition at line 92 of file FilterBodyFittedVelocity.h.

Referenced by v_FillVariablesName(), v_Initialise(), and v_ProcessSample().

◆ m_outFieldsThermalVars

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterBodyFittedVelocity::m_outFieldsThermalVars

protected

Definition at line 102 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_outFieldsVels

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterBodyFittedVelocity::m_outFieldsVels

protected

Definition at line 99 of file FilterBodyFittedVelocity.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_problemType

ProblemType Nektar::SolverUtils::FilterBodyFittedVelocity::m_problemType

protected

Definition at line 88 of file FilterBodyFittedVelocity.h.

Referenced by v_FillVariablesName(), v_Initialise(), and v_ProcessSample().

◆ m_spaceDim

unsigned int Nektar::SolverUtils::FilterBodyFittedVelocity::m_spaceDim

protected

Definition at line 89 of file FilterBodyFittedVelocity.h.

Referenced by v_FillVariablesName(), v_Initialise(), and v_ProcessSample().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ FilterType

◆ ProblemType

Constructor & Destructor Documentation

◆ FilterBodyFittedVelocity()

◆ ~FilterBodyFittedVelocity()

Member Function Documentation

◆ create()

◆ v_FillVariablesName()

◆ v_GetFileSuffix()

◆ v_GetScale()

◆ v_Initialise()

◆ v_PrepareOutput()

◆ v_ProcessSample()

Friends And Related Function Documentation

◆ MemoryManager< FilterBodyFittedVelocity >

Member Data Documentation

◆ className

◆ m_bfcsDir

◆ m_bfsVars

◆ m_bodyFittedCooriateFile

◆ m_curFieldsThermalVars

◆ m_curFieldsVels

◆ m_curFieldsVels_Car

◆ m_filterType

◆ m_initialized

◆ m_nAddFields

◆ m_nFields

◆ m_nVars

◆ m_outFieldsThermalVars

◆ m_outFieldsVels

◆ m_problemType

◆ m_spaceDim