Stagnation conditions inflow boundary conditions for compressible flow problems where the energy and density are prescribed. More...

#include <StagnationInflowBC.h>

Inheritance diagram for Nektar::StagnationInflowBC:

[legend]

Static Public Member Functions
static CFSBndCondSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, Array< OneD, NekDouble > > &pTraceNormals, const int pSpaceDim, const int bcRegion, const int cnt)
	Creates an instance of this class. More...

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

Protected Member Functions
void	v_Apply (Array< OneD, Array< OneD, NekDouble > > &Fwd, Array< OneD, Array< OneD, NekDouble > > &physarray, const NekDouble &time) override

Protected Member Functions inherited from Nektar::CFSBndCond
	CFSBndCond (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, Array< OneD, NekDouble > > &pTraceNormals, const int pSpaceDim, const int bcRegion, const int cnt)
	Constructor. More...

virtual void	v_Apply (Array< OneD, Array< OneD, NekDouble > > &Fwd, Array< OneD, Array< OneD, NekDouble > > &physarray, const NekDouble &time)=0

virtual void	v_ApplyBwdWeight ()

Private Member Functions
	StagnationInflowBC (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, Array< OneD, NekDouble > > &pTraceNormals, const int pSpaceDim, const int bcRegion, const int cnt)

	~StagnationInflowBC (void) override

Private Attributes
Array< OneD, Array< OneD, NekDouble > >	m_fieldStorage

Friends
class	MemoryManager< StagnationInflowBC >

Additional Inherited Members
Public Member Functions inherited from Nektar::CFSBndCond
virtual	~CFSBndCond ()

void	Apply (Array< OneD, Array< OneD, NekDouble > > &Fwd, Array< OneD, Array< OneD, NekDouble > > &physarray, const NekDouble &time=0)
	Apply the boundary condition. More...

void	ApplyBwdWeight ()
	Apply the Weight of boundary condition. More...

Protected Attributes inherited from Nektar::CFSBndCond
LibUtilities::SessionReaderSharedPtr	m_session
	Session reader. More...

Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Array of fields. More...

Array< OneD, Array< OneD, NekDouble > >	m_traceNormals
	Trace normals. More...

int	m_spacedim
	Space dimension. More...

VariableConverterSharedPtr	m_varConv
	Auxiliary object to convert variables. More...

NekDouble	m_diffusionAveWeight
	Weight for average calculation of diffusion term. More...

NekDouble	m_gamma
	Parameters of the flow. More...

NekDouble	m_rhoInf

NekDouble	m_pInf

NekDouble	m_pOut

Array< OneD, NekDouble >	m_velInf

int	m_bcRegion
	Id of the boundary region. More...

int	m_offset
	Offset. More...

Detailed Description

Stagnation conditions inflow boundary conditions for compressible flow problems where the energy and density are prescribed.

Definition at line 47 of file StagnationInflowBC.h.

Constructor & Destructor Documentation

◆ StagnationInflowBC()

Nektar::StagnationInflowBC::StagnationInflowBC	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const Array< OneD, Array< OneD, NekDouble > > &	pTraceNormals,
		const int	pSpaceDim,
		const int	bcRegion,
		const int	cnt
	)

private

Definition at line 47 of file StagnationInflowBC.cpp.

    : CFSBndCond(pSession, pFields, pTraceNormals, pSpaceDim, bcRegion, cnt)
{
    const size_t nvariables = m_fields.size();
    const int expdim        = m_fields[0]->GetGraph()->GetMeshDimension();
    const int spacedim      = m_fields[0]->GetGraph()->GetSpaceDimension();
    const int numBCPts =
        m_fields[0]->GetBndCondExpansions()[m_bcRegion]->GetNpoints();
 
    // Allocate internal storage for boundary condition values
    m_fieldStorage = Array<OneD, Array<OneD, NekDouble>>(nvariables);
    for (int i = 0; i < nvariables; ++i)
    {
        m_fieldStorage[i] = Array<OneD, NekDouble>(numBCPts, 0.0);
        Vmath::Vcopy(numBCPts,
                     m_fields[i]->GetBndCondExpansions()[m_bcRegion]->GetPhys(),
                     1, m_fieldStorage[i], 1);
    }
 
    // Compute the flow direction that will be imposed
    for (int j = 0; j < numBCPts; ++j)
    {
        // Compute norm of user-specified flow direction
        NekDouble dirNorm = 0.;
        for (int i = 0; i < spacedim; ++i)
        {
            dirNorm += std::pow(m_fieldStorage[i + 1][j], 2);
        }
        dirNorm = std::sqrt(dirNorm);
 
        // Use the user-specified flow direction if it's nonzero
        if (dirNorm > 1.E-8)
        {
            for (int i = 0; i < spacedim; ++i)
            {
                m_fieldStorage[i + 1][j] /= dirNorm;
            }
        }
        else
        {
            for (int i = 0; i < expdim; ++i)
            {
                m_fieldStorage[i + 1][j] = -m_traceNormals[i][j];
            }
            for (int i = expdim; i < spacedim; ++i)
            {
                m_fieldStorage[i + 1][j] = 0.;
            }
        }
    }
}

References Nektar::CFSBndCond::m_bcRegion, Nektar::CFSBndCond::m_fields, m_fieldStorage, Nektar::CFSBndCond::m_traceNormals, tinysimd::sqrt(), and Vmath::Vcopy().

◆ ~StagnationInflowBC()

Nektar::StagnationInflowBC::~StagnationInflowBC ( void )

inlineoverrideprivate

Definition at line 80 of file StagnationInflowBC.h.

80{};

Member Function Documentation

◆ create()

static CFSBndCondSharedPtr Nektar::StagnationInflowBC::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const Array< OneD, Array< OneD, NekDouble > > &	pTraceNormals,
		const int	pSpaceDim,
		const int	bcRegion,
		const int	cnt
	)

inlinestatic

Creates an instance of this class.

Definition at line 53 of file StagnationInflowBC.h.

    {
        CFSBndCondSharedPtr p =
            MemoryManager<StagnationInflowBC>::AllocateSharedPtr(
                pSession, pFields, pTraceNormals, pSpaceDim, bcRegion, cnt);
        return p;
    }

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

◆ v_Apply()

void Nektar::StagnationInflowBC::v_Apply	(	Array< OneD, Array< OneD, NekDouble > > &	Fwd,
		Array< OneD, Array< OneD, NekDouble > > &	physarray,
		const NekDouble &	time
	)

overrideprotectedvirtual

Implements Nektar::CFSBndCond.

Definition at line 103 of file StagnationInflowBC.cpp.

{
    const size_t nTracePts  = Fwd[0].size();
    const size_t nVariables = physarray.size();
 
    ASSERTL0(nTracePts == m_fields[0]->GetTrace()->GetNpoints(),
             "Number of trace points does not match in "
             "StagnationInflowBC::v_Apply()");
 
    const Array<OneD, const int> &traceBndMap = m_fields[0]->GetTraceBndMap();
 
    // Get velocity magnitude from Fwd
    Array<OneD, NekDouble> absVel(nTracePts, 0.0);
    m_varConv->GetAbsoluteVelocity(Fwd, absVel);
 
    // Loop over all elements on the boundary
    for (int e = 0;
         e < m_fields[0]->GetBndCondExpansions()[m_bcRegion]->GetExpSize(); ++e)
    {
        // Number of quadrature points in this element
        const int npts = m_fields[0]
                             ->GetBndCondExpansions()[m_bcRegion]
                             ->GetExp(e)
                             ->GetTotPoints();
        const int id1 =
            m_fields[0]->GetBndCondExpansions()[m_bcRegion]->GetPhys_Offset(e);
        const int id2 =
            m_fields[0]->GetTrace()->GetPhys_Offset(traceBndMap[m_offset + e]);
 
        // Loop over all quadrature points on this element
        for (int i = 0; i < npts; ++i)
        {
            // Copy conserved variables at stagnation state from BC
            NekDouble rhoStag = m_fieldStorage[0][id1 + i];
            NekDouble EStag   = m_fieldStorage[nVariables - 1][id1 + i];
 
            // Compute stagnation enthalpy
            NekDouble hStag = m_gamma * EStag / rhoStag;
 
            // Compute static enthalpy by solving 1D energy balance
            NekDouble hStat = hStag - 0.5 * pow(absVel[id2 + i], 2);
 
            // Compute density from isentropic flow relation
            NekDouble rho = rhoStag * pow(rhoStag * hStat / (EStag * m_gamma),
                                          1. / (m_gamma - 1.));
 
            // Update density for BC
            (m_fields[0]
                 ->GetBndCondExpansions()[m_bcRegion]
                 ->UpdatePhys())[id1 + i] = rho;
 
            // Update momentum for BC
            for (int n = 0; n < m_spacedim; ++n)
            {
                (m_fields[1 + n]
                     ->GetBndCondExpansions()[m_bcRegion]
                     ->UpdatePhys())[id1 + i] =
                    rho * absVel[id2 + i] * m_fieldStorage[1 + n][id1 + i];
            }
 
            // Update total energy for BC
            (m_fields[nVariables - 1]
                 ->GetBndCondExpansions()[m_bcRegion]
                 ->UpdatePhys())[id1 + i] =
                rho * (hStat / m_gamma + 0.5 * pow(absVel[id2 + i], 2));
        }
    }
}

References ASSERTL0, Nektar::CFSBndCond::m_bcRegion, Nektar::CFSBndCond::m_fields, m_fieldStorage, Nektar::CFSBndCond::m_gamma, Nektar::CFSBndCond::m_offset, Nektar::CFSBndCond::m_spacedim, and Nektar::CFSBndCond::m_varConv.

Friends And Related Function Documentation

◆ MemoryManager< StagnationInflowBC >

friend class MemoryManager< StagnationInflowBC >

friend

Definition at line 1 of file StagnationInflowBC.h.

Member Data Documentation

◆ className

std::string Nektar::StagnationInflowBC::className

static

Initial value:

=
    GetCFSBndCondFactory().RegisterCreatorFunction(
        "StagnationInflow", StagnationInflowBC::create,
        "Stagnation conditions inflow boundary condition.")

Name of the class.

Definition at line 66 of file StagnationInflowBC.h.

◆ m_fieldStorage

Array<OneD, Array<OneD, NekDouble> > Nektar::StagnationInflowBC::m_fieldStorage

private

Definition at line 83 of file StagnationInflowBC.h.

Referenced by StagnationInflowBC(), and v_Apply().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members