Nektar::SmoothShockCapture Class Reference

Smooth artificial diffusion for shock capture for compressible flow problems. More...

#include <SmoothShockCapture.h>

Inheritance diagram for Nektar::SmoothShockCapture:

Collaboration diagram for Nektar::SmoothShockCapture:

Static Public Member Functions
static ArtificialDiffusionSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int spacedim)
	Creates an instance of this class. More...

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

Protected Member Functions
virtual void	v_DoArtificialDiffusion (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
virtual void	v_GetArtificialViscosity (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &mu)
Protected Member Functions inherited from Nektar::ArtificialDiffusion
	ArtificialDiffusion (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int spacedim)
	Constructor. More...

Private Member Functions
	SmoothShockCapture (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int spacedim)
virtual	~SmoothShockCapture (void)
void	GetForcingTerm (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > outarrayForcing)

Friends
class	MemoryManager< SmoothShockCapture >

Additional Inherited Members
Public Member Functions inherited from Nektar::ArtificialDiffusion
virtual	~ArtificialDiffusion ()
void	DoArtificialDiffusion (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Apply the artificial diffusion. More...
void	GetArtificialViscosity (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &mu)
	Calculate the artificial viscosity. More...
Protected Attributes inherited from Nektar::ArtificialDiffusion
LibUtilities::SessionReaderSharedPtr	m_session
	Session reader. More...
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Array of fields. More...
VariableConverterSharedPtr	m_varConv
	Auxiliary object to convert variables. More...
SolverUtils::DiffusionSharedPtr	m_diffusion
	LDG Diffusion operator. More...
NekDouble	m_FacL
	Parameters. More...
NekDouble	m_FacH
NekDouble	m_hFactor
NekDouble	m_C1
NekDouble	m_C2
NekDouble	m_mu0
NekDouble	m_Skappa
NekDouble	m_Kappa

Detailed Description

Smooth artificial diffusion for shock capture for compressible flow problems.

Definition at line 49 of file SmoothShockCapture.h.

Constructor & Destructor Documentation

Nektar::SmoothShockCapture::SmoothShockCapture ( const LibUtilities::SessionReaderSharedPtr &  pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const int  spacedim  )

private

Definition at line 48 of file SmoothShockCapture.cpp.

References ASSERTL0, and Nektar::ArtificialDiffusion::m_fields.

    : ArtificialDiffusion(pSession, pFields, spacedim)
{
    ASSERTL0(m_fields.num_elements() == spacedim + 3,
             "Not enough variables for smooth shock capturing; "
             "make sure you have added eps to variable list.");
}

virtual Nektar::SmoothShockCapture::~SmoothShockCapture ( void  )

inlineprivatevirtual

Definition at line 84 of file SmoothShockCapture.h.

{};

Member Function Documentation

static ArtificialDiffusionSharedPtr Nektar::SmoothShockCapture::create ( const LibUtilities::SessionReaderSharedPtr &  pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const int  spacedim  )

inlinestatic

Creates an instance of this class.

Definition at line 56 of file SmoothShockCapture.h.

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

        {
            ArtificialDiffusionSharedPtr p = MemoryManager<SmoothShockCapture>::
                                AllocateSharedPtr(pSession, pFields, spacedim);
            return p;
        }

void Nektar::SmoothShockCapture::GetForcingTerm ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > >  outarrayForcing  )

private

Definition at line 162 of file SmoothShockCapture.cpp.

References Nektar::ArtificialDiffusion::m_C1, Nektar::ArtificialDiffusion::m_fields, Nektar::ArtificialDiffusion::m_hFactor, Nektar::ArtificialDiffusion::m_varConv, Vmath::Vadd(), and Vmath::Vmax().

Referenced by v_DoArtificialDiffusion().

{
    const int nPts = m_fields[0]->GetTotPoints();
    const int nvariables = m_fields.num_elements();
    const int nElements = m_fields[0]->GetExpSize();

    Array<OneD,  NekDouble>  Sensor(nPts, 0.0);
    Array<OneD,  NekDouble>  SensorKappa(nPts, 0.0);
    Array <OneD, NekDouble > Lambda(nPts, 0.0);
    Array <OneD, NekDouble > Tau(nPts, 1.0);
    Array <OneD, NekDouble > soundspeed(nPts, 0.0);
    Array <OneD, NekDouble > pressure(nPts, 0.0);
    Array <OneD, NekDouble > absVelocity(nPts, 0.0);

    Array<OneD,int> pOrderElmt = m_fields[0]->EvalBasisNumModesMaxPerExp();
    Array<OneD, NekDouble> pOrder (nPts, 0.0);

    // Thermodynamic related quantities
    m_varConv->GetPressure(inarray, pressure);
    m_varConv->GetSoundSpeed(inarray, pressure, soundspeed);
    m_varConv->GetAbsoluteVelocity(inarray, absVelocity);
    m_varConv->GetSensor(m_fields[0], inarray, Sensor, SensorKappa);

    // Determine the maximum wavespeed
    Vmath::Vadd(nPts, absVelocity, 1, soundspeed, 1, Lambda, 1);

    NekDouble LambdaMax = Vmath::Vmax(nPts, Lambda, 1);

    int PointCount = 0;

    for (int e = 0; e < nElements; e++)
    {
        int nQuadPointsElement = m_fields[0]->GetExp(e)->GetTotPoints();

        for (int n = 0; n < nQuadPointsElement; n++)
        {
            pOrder[n + PointCount] = pOrderElmt[e];

            // order 1.0e-06
            Tau[n + PointCount] =
                1.0 / (m_C1*pOrder[n + PointCount]*LambdaMax);

            outarrayForcing[nvariables-1][n + PointCount] =
                1 / Tau[n + PointCount] * (m_hFactor * LambdaMax /
                                    pOrder[n + PointCount] *
                                    SensorKappa[n + PointCount] -
                                    inarray[nvariables-1][n + PointCount]);
        }
        PointCount += nQuadPointsElement;
    }
}

void Nektar::SmoothShockCapture::v_DoArtificialDiffusion ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

protectedvirtual

Reimplemented from Nektar::ArtificialDiffusion.

Definition at line 58 of file SmoothShockCapture.cpp.

References GetForcingTerm(), Nektar::ArtificialDiffusion::m_C2, Nektar::ArtificialDiffusion::m_diffusion, Nektar::ArtificialDiffusion::m_fields, Nektar::ArtificialDiffusion::m_varConv, Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmax().

{
    int i;
    int nvariables = inarray.num_elements();
    int npoints    = m_fields[0]->GetNpoints();

    Array<OneD, Array<OneD, NekDouble> > outarrayDiff(nvariables);

    for (i = 0; i < nvariables; ++i)
    {
        outarrayDiff[i] = Array<OneD, NekDouble>(npoints, 0.0);
    }

    m_diffusion->Diffuse(nvariables, m_fields, inarray, outarrayDiff);

    const Array<OneD, int> ExpOrder = m_fields[0]->EvalBasisNumModesMaxPerExp();

    NekDouble pOrder = Vmath::Vmax(ExpOrder.num_elements(), ExpOrder, 1);

    Array <OneD, NekDouble > a_vel  (npoints, 0.0);
    Array <OneD, NekDouble > u_abs  (npoints, 0.0);
    Array <OneD, NekDouble > tmp   (npoints, 0.0);

    m_varConv->GetPressure(inarray, tmp);
    m_varConv->GetSoundSpeed(inarray, tmp, a_vel);
    m_varConv->GetAbsoluteVelocity(inarray, u_abs);

    Vmath::Vadd(npoints, a_vel, 1, u_abs, 1, tmp, 1);

    NekDouble max_wave_sp = Vmath::Vmax(npoints, tmp, 1);

    NekDouble fac = m_C2*max_wave_sp*pOrder;

    Vmath::Smul(npoints,
                fac,
                outarrayDiff[nvariables-1], 1,
                outarrayDiff[nvariables-1], 1);

    for (i = 0; i < nvariables; ++i)
    {
        Vmath::Vadd(npoints,
                    outarray[i], 1,
                    outarrayDiff[i], 1,
                    outarray[i], 1);
    }

    Array<OneD, Array<OneD, NekDouble> > outarrayForcing(nvariables);

    for (i = 0; i < nvariables; ++i)
    {
        outarrayForcing[i] = Array<OneD, NekDouble>(npoints, 0.0);
    }

    GetForcingTerm(inarray, outarrayForcing);

    for (i = 0; i < nvariables; ++i)
    {
        // Add Forcing Term
        Vmath::Vadd(npoints,
                    outarray[i], 1,
                    outarrayForcing[i], 1,
                    outarray[i], 1);
    }
}

void Nektar::SmoothShockCapture::v_GetArtificialViscosity ( const Array< OneD, Array< OneD, NekDouble > > &  physfield, Array< OneD, NekDouble > &  mu  )

protectedvirtual

Implements Nektar::ArtificialDiffusion.

Definition at line 125 of file SmoothShockCapture.cpp.

References Nektar::ArtificialDiffusion::m_FacH, Nektar::ArtificialDiffusion::m_FacL, Nektar::ArtificialDiffusion::m_fields, Nektar::ArtificialDiffusion::m_mu0, and Nektar::ArtificialDiffusion::m_varConv.

{
    int nvariables = physfield.num_elements();
    int nPts       = m_fields[0]->GetTotPoints();

    Array<OneD, NekDouble > sensor     (nPts, 0.0);
    Array<OneD, NekDouble > SensorKappa(nPts, 0.0);

    // Calculate sensor
    m_varConv->GetSensor(m_fields[0], physfield, sensor, SensorKappa);

    NekDouble ThetaH = m_FacH;
    NekDouble ThetaL = m_FacL;

    NekDouble Phi0     = (ThetaH+ThetaL)/2;
    NekDouble DeltaPhi = ThetaH-Phi0;

    for (int e = 0; e < mu.num_elements(); e++)
    {
        if (physfield[nvariables-1][e] <= (Phi0 - DeltaPhi))
        {
            mu[e] = 0;
        }
        else if(physfield[nvariables-1][e] >= (Phi0 + DeltaPhi))
        {
            mu[e] = m_mu0;
        }
        else if(abs(physfield[nvariables-1][e]-Phi0) < DeltaPhi)
        {
            mu[e] = m_mu0/2*(1+sin(M_PI*
                (physfield[nvariables-1][e]-Phi0)/(2*DeltaPhi)));
        }
    }
}

Friends And Related Function Documentation

friend class MemoryManager< SmoothShockCapture >

friend

Definition at line 53 of file SmoothShockCapture.h.

Member Data Documentation

std::string Nektar::SmoothShockCapture::className

static

Initial value:

= GetArtificialDiffusionFactory().
    RegisterCreatorFunction("Smooth",
                            SmoothShockCapture::create,
                            "Smooth artificial diffusion for shock capture.")

Name of the class.

Definition at line 67 of file SmoothShockCapture.h.