Nektar::SkewSymmetricAdvection Class Reference

#include <SkewSymmetricAdvection.h>

Inheritance diagram for Nektar::SkewSymmetricAdvection:

Static Public Member Functions
static SolverUtils::AdvectionSharedPtr	create (std::string)
	Creates an instance of this class. More...

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

Protected Member Functions
	SkewSymmetricAdvection ()
	~SkewSymmetricAdvection () override=default
void	v_InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields) override
	Initialises the advection object. More...
void	v_Advect (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &advVel, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray) override
	Advects a vector field. More...
Protected Member Functions inherited from Nektar::SolverUtils::Advection
virtual SOLVER_UTILS_EXPORT	~Advection ()=default
virtual SOLVER_UTILS_EXPORT void	v_InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
	Initialises the advection object. More...
virtual SOLVER_UTILS_EXPORT void	v_Advect (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &advVel, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray)=0
	Advects a vector field. More...
virtual SOLVER_UTILS_EXPORT void	v_SetBaseFlow (const Array< OneD, Array< OneD, NekDouble > > &inarray, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
	Overrides the base flow used during linearised advection. More...

Private Attributes
bool	m_homogen_dealiasing
bool	m_SingleMode
bool	m_HalfMode

Friends
class	MemoryManager< SkewSymmetricAdvection >

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::Advection
SOLVER_UTILS_EXPORT void	InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
	Interface function to initialise the advection object. More...
SOLVER_UTILS_EXPORT void	Advect (const int nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &advVel, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time, const Array< OneD, Array< OneD, NekDouble > > &pFwd=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &pBwd=NullNekDoubleArrayOfArray)
	Interface function to advect the vector field. More...
template<typename FuncPointerT , typename ObjectPointerT >
void	SetFluxVector (FuncPointerT func, ObjectPointerT obj)
	Set the flux vector callback function. More...
void	SetRiemannSolver (RiemannSolverSharedPtr riemann)
	Set a Riemann solver object for this advection object. More...
void	SetFluxVector (AdvectionFluxVecCB fluxVector)
	Set the flux vector callback function. More...
void	SetBaseFlow (const Array< OneD, Array< OneD, NekDouble > > &inarray, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
	Set the base flow used for linearised advection objects. More...
template<typename DataType , typename TypeNekBlkMatSharedPtr >
SOLVER_UTILS_EXPORT void	AddTraceJacToMat (const int nConvectiveFields, const int nSpaceDim, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacCons, Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacGrad, const Array< OneD, Array< OneD, DataType > > &TracePntJacGradSign)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	CalcJacobTraceInteg (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int m, const int n, const Array< OneD, const TypeNekBlkMatSharedPtr > &PntJac, const Array< OneD, const Array< OneD, DataType > > &PntJacSign, Array< OneD, DNekMatSharedPtr > &TraceJacFwd, Array< OneD, DNekMatSharedPtr > &TraceJacBwd)
template<typename DataType , typename TypeNekBlkMatSharedPtr >
void	AddTraceJacToMat (const int nConvectiveFields, const int nSpaceDim, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacCons, Array< OneD, Array< OneD, TypeNekBlkMatSharedPtr > > &gmtxarray, const Array< OneD, TypeNekBlkMatSharedPtr > &TracePntJacGrad, const Array< OneD, Array< OneD, DataType > > &TracePntJacGradSign)
Protected Attributes inherited from Nektar::SolverUtils::Advection
AdvectionFluxVecCB	m_fluxVector
	Callback function to the flux vector (set when advection is in conservative form). More...
RiemannSolverSharedPtr	m_riemann
	Riemann solver for DG-type schemes. More...
int	m_spaceDim
	Storage for space dimension. Used for homogeneous extension. More...

Detailed Description

Definition at line 44 of file SkewSymmetricAdvection.h.

Constructor & Destructor Documentation

SkewSymmetricAdvection()

Nektar::SkewSymmetricAdvection::SkewSymmetricAdvection ( )

protected

Definition at line 46 of file SkewSymmetricAdvection.cpp.

                                               : Advection()
 
{
}

~SkewSymmetricAdvection()

Nektar::SkewSymmetricAdvection::~SkewSymmetricAdvection ( )

overrideprotecteddefault

Member Function Documentation

create()

static SolverUtils::AdvectionSharedPtr Nektar::SkewSymmetricAdvection::create ( std::string  )

inlinestatic

Creates an instance of this class.

Definition at line 50 of file SkewSymmetricAdvection.h.

    {
        return MemoryManager<SkewSymmetricAdvection>::AllocateSharedPtr();
    }

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

v_Advect()

void Nektar::SkewSymmetricAdvection::v_Advect ( const int  nConvectiveFields, const Array< OneD, MultiRegions::ExpListSharedPtr > &  fields, const Array< OneD, Array< OneD, NekDouble > > &  advVel, const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const NekDouble &  time, const Array< OneD, Array< OneD, NekDouble > > &  pFwd = NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &  pBwd = NullNekDoubleArrayOfArray  )

overrideprotectedvirtual

Advects a vector field.

Implements Nektar::SolverUtils::Advection.

Definition at line 68 of file SkewSymmetricAdvection.cpp.

{
    // use dimension of Velocity vector to dictate dimension of operation
    int ndim  = advVel.size();
    int nqtot = fields[0]->GetTotPoints();
    ASSERTL1(nConvectiveFields == inarray.size(),
             "Number of convective fields and Inarray are not compatible");
 
    Array<OneD, Array<OneD, NekDouble>> velocity(ndim);
    for (int i = 0; i < ndim; ++i)
    {
        if (fields[i]->GetWaveSpace() && !m_SingleMode && !m_HalfMode)
        {
            velocity[i] = Array<OneD, NekDouble>(nqtot, 0.0);
            fields[i]->HomogeneousBwdTrans(nqtot, advVel[i], velocity[i]);
        }
        else
        {
            velocity[i] = advVel[i];
        }
    }
 
    for (int n = 0; n < nConvectiveFields; ++n)
    {
        // ToDo: here we should add a check that V has right dimension
 
        int nPointsTot = fields[0]->GetNpoints();
        Array<OneD, NekDouble> gradV0, gradV1, gradV2, tmp, Up;
 
        gradV0 = Array<OneD, NekDouble>(nPointsTot);
        tmp    = Array<OneD, NekDouble>(nPointsTot);
 
        // Evaluate V\cdot Grad(u)
        switch (ndim)
        {
            case 1:
                fields[0]->PhysDeriv(inarray[n], gradV0);
                Vmath::Vmul(nPointsTot, gradV0, 1, velocity[0], 1, outarray[n],
                            1);
                Vmath::Vmul(nPointsTot, inarray[n], 1, velocity[0], 1, gradV0,
                            1);
                fields[0]->PhysDeriv(gradV0, tmp);
                Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n], 1);
                Vmath::Smul(nPointsTot, 0.5, outarray[n], 1, outarray[n], 1);
                break;
            case 2:
                gradV1 = Array<OneD, NekDouble>(nPointsTot);
                fields[0]->PhysDeriv(inarray[n], gradV0, gradV1);
                Vmath::Vmul(nPointsTot, gradV0, 1, velocity[0], 1, outarray[n],
                            1);
                Vmath::Vvtvp(nPointsTot, gradV1, 1, velocity[1], 1, outarray[n],
                             1, outarray[n], 1);
                Vmath::Vmul(nPointsTot, inarray[n], 1, velocity[0], 1, gradV0,
                            1);
                Vmath::Vmul(nPointsTot, inarray[n], 1, velocity[1], 1, gradV1,
                            1);
                fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], gradV0,
                                     tmp);
                Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n], 1);
                fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], gradV1,
                                     tmp);
                Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n], 1);
                Vmath::Smul(nPointsTot, 0.5, outarray[n], 1, outarray[n], 1);
                break;
            case 3:
                gradV1 = Array<OneD, NekDouble>(nPointsTot);
                gradV2 = Array<OneD, NekDouble>(nPointsTot);
 
                fields[0]->PhysDeriv(inarray[n], gradV0, gradV1, gradV2);
 
                // outarray[n] = 1/2(u*du/dx + v*du/dy + w*du/dz + duu/dx +
                // duv/dy + duw/dz)
 
                if (m_homogen_dealiasing == true &&
                    fields[0]->GetWaveSpace() == false)
                {
                    fields[0]->DealiasedProd(nPointsTot, velocity[0], gradV0,
                                             gradV0);
                    fields[0]->DealiasedProd(nPointsTot, velocity[1], gradV1,
                                             gradV1);
                    fields[0]->DealiasedProd(nPointsTot, velocity[2], gradV2,
                                             gradV2);
                    Vmath::Vadd(nPointsTot, gradV0, 1, gradV1, 1, outarray[n],
                                1);
                    Vmath::Vadd(nPointsTot, gradV2, 1, outarray[n], 1,
                                outarray[n], 1);
                    fields[0]->DealiasedProd(nPointsTot, inarray[n],
                                             velocity[0], gradV0);
                    fields[0]->DealiasedProd(nPointsTot, inarray[n],
                                             velocity[1], gradV1);
                    fields[0]->DealiasedProd(nPointsTot, inarray[n],
                                             velocity[2], gradV2);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                         gradV0, tmp);
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                         gradV1, tmp);
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                         gradV2, tmp);
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    Vmath::Smul(nPointsTot, 0.5, outarray[n], 1, outarray[n],
                                1);
                }
                else if (fields[0]->GetWaveSpace() == true &&
                         m_homogen_dealiasing == false)
                {
                    Up = Array<OneD, NekDouble>(nPointsTot);
                    // vector reused to avoid even more memory requirements
                    // names may be misleading
                    fields[0]->HomogeneousBwdTrans(nPointsTot, gradV0, tmp);
                    Vmath::Vmul(nPointsTot, tmp, 1, velocity[0], 1, outarray[n],
                                1); // + u*du/dx
                    fields[0]->HomogeneousBwdTrans(nPointsTot, gradV1, tmp);
                    Vmath::Vvtvp(nPointsTot, tmp, 1, velocity[1], 1,
                                 outarray[n], 1, outarray[n], 1); // + v*du/dy
                    fields[0]->HomogeneousBwdTrans(nPointsTot, gradV2, tmp);
                    Vmath::Vvtvp(nPointsTot, tmp, 1, velocity[2], 1,
                                 outarray[n], 1, outarray[n], 1); // + w*du/dz
 
                    fields[0]->HomogeneousBwdTrans(nPointsTot, inarray[n], Up);
                    Vmath::Vmul(nPointsTot, Up, 1, velocity[0], 1, gradV0, 1);
                    Vmath::Vmul(nPointsTot, Up, 1, velocity[1], 1, gradV1, 1);
                    Vmath::Vmul(nPointsTot, Up, 1, velocity[2], 1, gradV2, 1);
 
                    fields[0]->SetWaveSpace(false);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                         gradV0, tmp); // duu/dx
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                         gradV1, tmp); // duv/dy
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                         gradV2, tmp); // duw/dz
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->SetWaveSpace(true);
 
                    Vmath::Smul(nPointsTot, 0.5, outarray[n], 1, tmp, 1);
                    fields[0]->HomogeneousFwdTrans(nPointsTot, tmp,
                                                   outarray[n]);
                }
                else if (fields[0]->GetWaveSpace() == false &&
                         m_homogen_dealiasing == false)
                {
                    Vmath::Vmul(nPointsTot, gradV0, 1, velocity[0], 1,
                                outarray[n], 1);
                    Vmath::Vvtvp(nPointsTot, gradV1, 1, velocity[1], 1,
                                 outarray[n], 1, outarray[n], 1);
                    Vmath::Vvtvp(nPointsTot, gradV2, 1, velocity[2], 1,
                                 outarray[n], 1, outarray[n], 1);
                    Vmath::Vmul(nPointsTot, inarray[n], 1, velocity[0], 1,
                                gradV0, 1);
                    Vmath::Vmul(nPointsTot, inarray[n], 1, velocity[1], 1,
                                gradV1, 1);
                    Vmath::Vmul(nPointsTot, inarray[n], 1, velocity[2], 1,
                                gradV2, 1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                         gradV0, tmp);
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                         gradV1, tmp);
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                         gradV2, tmp);
                    Vmath::Vadd(nPointsTot, tmp, 1, outarray[n], 1, outarray[n],
                                1);
                    Vmath::Smul(nPointsTot, 0.5, outarray[n], 1, outarray[n],
                                1);
                }
                else
                {
                    ASSERTL0(false,
                             "Dealiasing is not allowed in combination "
                             "with the Skew-Symmetric advection form for "
                             "efficiency reasons.");
                }
                break;
            default:
                ASSERTL0(false, "dimension unknown");
        }
 
        Vmath::Neg(nqtot, outarray[n], 1);
    }
}

References ASSERTL0, ASSERTL1, Nektar::MultiRegions::DirCartesianMap, m_HalfMode, m_homogen_dealiasing, m_SingleMode, Vmath::Neg(), Vmath::Smul(), Vmath::Vadd(), Vmath::Vmul(), and Vmath::Vvtvp().

v_InitObject()

void Nektar::SkewSymmetricAdvection::v_InitObject ( LibUtilities::SessionReaderSharedPtr  pSession, Array< OneD, MultiRegions::ExpListSharedPtr >  pFields  )

overrideprotectedvirtual

Initialises the advection object.

This function should be overridden in derived classes to initialise the specific advection data members. However, this base class function should be called as the first statement of the overridden function to ensure the base class is correctly initialised in order.

Parameters

pSession	Session information.
pFields	Expansion lists for scalar fields.

Reimplemented from Nektar::SolverUtils::Advection.

Definition at line 54 of file SkewSymmetricAdvection.cpp.

{
    Advection::v_InitObject(pSession, pFields);
 
    m_homogen_dealiasing = pSession->DefinesSolverInfo("dealiasing");
    pSession->MatchSolverInfo("ModeType", "SingleMode", m_SingleMode, false);
    pSession->MatchSolverInfo("ModeType", "HalfMode", m_HalfMode, false);
}

References m_HalfMode, m_homogen_dealiasing, m_SingleMode, and Nektar::SolverUtils::Advection::v_InitObject().

Friends And Related Function Documentation

MemoryManager< SkewSymmetricAdvection >

friend class MemoryManager< SkewSymmetricAdvection >

friend

Definition at line 1 of file SkewSymmetricAdvection.h.

Member Data Documentation

className

std::string Nektar::SkewSymmetricAdvection::className

static

Initial value:

=
    SolverUtils::GetAdvectionFactory().RegisterCreatorFunction(
        "SkewSymmetric", SkewSymmetricAdvection::create, "Skew Symmetric")

Name of class.

Definition at line 56 of file SkewSymmetricAdvection.h.

className2

std::string Nektar::SkewSymmetricAdvection::className2

static

Definition at line 57 of file SkewSymmetricAdvection.h.

m_HalfMode

bool Nektar::SkewSymmetricAdvection::m_HalfMode

private

Definition at line 82 of file SkewSymmetricAdvection.h.

Referenced by v_Advect(), and v_InitObject().

m_homogen_dealiasing

bool Nektar::SkewSymmetricAdvection::m_homogen_dealiasing

private

Definition at line 80 of file SkewSymmetricAdvection.h.

Referenced by v_Advect(), and v_InitObject().

m_SingleMode

bool Nektar::SkewSymmetricAdvection::m_SingleMode

private

Definition at line 81 of file SkewSymmetricAdvection.h.

Referenced by v_Advect(), and v_InitObject().