An abstract base class encapsulating the concept of advection of a vector field. More...

#include <Advection.h>

Inheritance diagram for Nektar::SolverUtils::Advection:

Public Member Functions
virtual SOLVER_UTILS_EXPORT	~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 Member Functions
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...

Protected Attributes
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

An abstract base class encapsulating the concept of advection of a vector field.

Subclasses override the Advection::v_InitObject function to initialise the object and the Advection::v_Advect function to evaluate the advection of the vector field.

Definition at line 82 of file Advection.h.

Constructor & Destructor Documentation

◆ ~Advection()

virtual SOLVER_UTILS_EXPORT Nektar::SolverUtils::Advection::~Advection ( )

inlinevirtual

Definition at line 85 of file Advection.h.

85{};

Member Function Documentation

◆ AddTraceJacToMat() [1/2]

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::SolverUtils::Advection::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
	)

Definition at line 85 of file Advection.cpp.

{
    MultiRegions::ExpListSharedPtr tracelist = pFields[0]->GetTrace();
    std::shared_ptr<LocalRegions::ExpansionVector> traceExp =
        tracelist->GetExp();
    int ntotTrac   = (*traceExp).size();
    int nTracePnts = tracelist->GetTotPoints();
    int nTracPnt, nTracCoef;
 
    DNekMatSharedPtr tmp2Add;
    Array<OneD, DataType> MatData0;
    Array<OneD, NekDouble> MatData1;
    Array<OneD, NekDouble> MatData2;
 
    Array<OneD, DNekMatSharedPtr> TraceJacFwd(ntotTrac);
    Array<OneD, DNekMatSharedPtr> TraceJacBwd(ntotTrac);
 
    for (int nelmt = 0; nelmt < ntotTrac; nelmt++)
    {
        nTracCoef = (*traceExp)[nelmt]->GetNcoeffs();
        nTracPnt  = (*traceExp)[nelmt]->GetTotPoints();
        TraceJacFwd[nelmt] =
            MemoryManager<DNekMat>::AllocateSharedPtr(nTracCoef, nTracPnt, 0.0);
        TraceJacBwd[nelmt] =
            MemoryManager<DNekMat>::AllocateSharedPtr(nTracCoef, nTracPnt, 0.0);
    }
 
    std::shared_ptr<LocalRegions::ExpansionVector> fieldExp =
        pFields[0]->GetExp();
    int nTotElmt = (*fieldExp).size();
    int nElmtPnt, nElmtCoef;
 
    Array<OneD, DNekMatSharedPtr> ElmtJacQuad(nTotElmt);
    Array<OneD, DNekMatSharedPtr> ElmtJacCoef(nTotElmt);
 
    Array<OneD, NekDouble> SymmMatData;
 
    for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
    {
        nElmtCoef = (*fieldExp)[nelmt]->GetNcoeffs();
        nElmtPnt  = (*fieldExp)[nelmt]->GetTotPoints();
 
        ElmtJacQuad[nelmt] =
            MemoryManager<DNekMat>::AllocateSharedPtr(nElmtCoef, nElmtPnt, 0.0);
        ElmtJacCoef[nelmt] = MemoryManager<DNekMat>::AllocateSharedPtr(
            nElmtCoef, nElmtCoef, 0.0);
    }
 
    bool TracePntJacGradflag = true;
 
    Array<OneD, Array<OneD, DataType>> TraceJacConsSign(2);
    for (int i = 0; i < 2; i++)
    {
        TraceJacConsSign[i] = Array<OneD, DataType>(nTracePnts, 1.0);
    }
 
    if (0 == TracePntJacGrad.size())
    {
        TracePntJacGradflag = false;
    }
 
    for (int m = 0; m < nConvectiveFields; m++)
    {
        for (int n = 0; n < nConvectiveFields; n++)
        {
            // ElmtJacCons to set 0
            for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
            {
                (*ElmtJacCoef[nelmt]) = 0.0;
                (*ElmtJacQuad[nelmt]) = 0.0;
            }
 
            if (TracePntJacGradflag)
            {
                // only BJac is stored here because BJac = - FJac
                for (int ndir = 0; ndir < nSpaceDim; ndir++)
                {
                    // ElmtJacGrad to set 0
                    for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
                    {
                        (*ElmtJacQuad[nelmt]) = 0.0;
                    }
                    int ngrad = n * nSpaceDim + ndir;
 
                    CalcJacobTraceInteg(pFields, m, ngrad, TracePntJacGrad,
                                        TracePntJacGradSign, TraceJacFwd,
                                        TraceJacBwd);
                    pFields[0]->AddTraceJacToElmtJac(TraceJacFwd, TraceJacBwd,
                                                     ElmtJacQuad);
                    // cost can be lower down by doing 3 directions together
                    pFields[0]->AddRightIPTPhysDerivBase(ndir, ElmtJacQuad,
                                                         ElmtJacCoef);
                }
                for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
                {
                    nElmtCoef = (*fieldExp)[nelmt]->GetNcoeffs();
                    if (SymmMatData.size() < nElmtCoef)
                    {
                        SymmMatData =
                            Array<OneD, NekDouble>(nElmtCoef * nElmtCoef);
                    }
                    MatData1 = ElmtJacCoef[nelmt]->GetPtr();
                    for (int i = 0; i < nElmtCoef; i++)
                    {
                        Vmath::Vcopy(nElmtCoef, &MatData1[i * nElmtCoef], 1,
                                     &SymmMatData[i], nElmtCoef);
                    }
                    Vmath::Vadd(nElmtCoef * nElmtCoef, SymmMatData, 1, MatData1,
                                1, MatData1, 1);
                }
            }
 
            CalcJacobTraceInteg(pFields, m, n, TracePntJacCons,
                                TraceJacConsSign, TraceJacFwd, TraceJacBwd);
 
            pFields[0]->AddTraceJacToElmtJac(TraceJacFwd, TraceJacBwd,
                                             ElmtJacQuad);
            // Memory can be save to explore reusing ElmtJacQuad as output
            pFields[0]->AddRightIPTBaseMatrix(ElmtJacQuad, ElmtJacCoef);
 
            // add ElmtJacCons to gmtxarray[m][n]
            for (int nelmt = 0; nelmt < nTotElmt; nelmt++)
            {
                tmp2Add  = ElmtJacCoef[nelmt];
                MatData0 = gmtxarray[m][n]->GetBlock(nelmt, nelmt)->GetPtr();
                MatData1 = tmp2Add->GetPtr();
                for (int i = 0; i < MatData0.size(); i++)
                {
                    MatData0[i] += DataType(MatData1[i]);
                }
            }
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), CalcJacobTraceInteg(), Nektar::Array< OneD, const DataType >::size(), Vmath::Vadd(), and Vmath::Vcopy().

◆ AddTraceJacToMat() [2/2]

template<typename DataType , typename TypeNekBlkMatSharedPtr >

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::Advection::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
	)

◆ Advect()

void Nektar::SolverUtils::Advection::Advect	(	const int	nConvectiveFields,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const Array< OneD, Array< OneD, NekDouble > > &	pAdvVel,
		const Array< OneD, Array< OneD, NekDouble > > &	pInarray,
		Array< OneD, Array< OneD, NekDouble > > &	pOutarray,
		const NekDouble &	pTime,
		const Array< OneD, Array< OneD, NekDouble > > &	pFwd = `NullNekDoubleArrayOfArray`,
		const Array< OneD, Array< OneD, NekDouble > > &	pBwd = `NullNekDoubleArrayOfArray`
	)

Interface function to advect the vector field.

Parameters

nConvectiveFields	Number of velocity components.
pFields	Expansion lists for scalar fields.
pAdvVel	Advection velocity.
pInarray	Scalar data to advect.
pOutarray	Advected scalar data.
pTime	Simulation time.

Definition at line 71 of file Advection.cpp.

{
    v_Advect(nConvectiveFields, pFields, pAdvVel, pInarray, pOutarray, pTime,
             pFwd, pBwd);
}

References v_Advect().

◆ CalcJacobTraceInteg()

template<typename DataType , typename TypeNekBlkMatSharedPtr >

void Nektar::SolverUtils::Advection::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
	)

Definition at line 245 of file Advection.cpp.

{
    MultiRegions::ExpListSharedPtr tracelist = pFields[0]->GetTrace();
    std::shared_ptr<LocalRegions::ExpansionVector> traceExp =
        tracelist->GetExp();
    int ntotTrac = (*traceExp).size();
    int nTracPnt, noffset, pntoffset;
 
    Array<OneD, int> tracepnts(ntotTrac);
    Array<OneD, Array<OneD, NekDouble>> JacFwd(ntotTrac);
    Array<OneD, Array<OneD, NekDouble>> JacBwd(ntotTrac);
 
    for (int nelmt = 0; nelmt < ntotTrac; nelmt++)
    {
        nTracPnt         = (*traceExp)[nelmt]->GetTotPoints();
        tracepnts[nelmt] = nTracPnt;
 
        JacFwd[nelmt] = Array<OneD, NekDouble>(nTracPnt, 0.0);
        JacBwd[nelmt] = Array<OneD, NekDouble>(nTracPnt, 0.0);
    }
 
    DataType ftmp, btmp;
    for (int nelmt = 0; nelmt < ntotTrac; nelmt++)
    {
        nTracPnt = tracepnts[nelmt];
        noffset  = tracelist->GetPhys_Offset(nelmt);
        for (int npnt = 0; npnt < nTracPnt; npnt++)
        {
            pntoffset = noffset + npnt;
            ftmp      = (*PntJac[0]->GetBlock(pntoffset, pntoffset))(m, n);
            JacFwd[nelmt][npnt] = NekDouble(PntJacSign[0][pntoffset] * ftmp);
 
            btmp = (*PntJac[1]->GetBlock(pntoffset, pntoffset))(m, n);
            JacBwd[nelmt][npnt] = NekDouble(PntJacSign[1][pntoffset] * btmp);
        }
    }
    tracelist->GetDiagMatIpwrtBase(JacFwd, TraceJacFwd);
    tracelist->GetDiagMatIpwrtBase(JacBwd, TraceJacBwd);
}

Referenced by AddTraceJacToMat().

◆ InitObject()

void Nektar::SolverUtils::Advection::InitObject	(	LibUtilities::SessionReaderSharedPtr	pSession,
		Array< OneD, MultiRegions::ExpListSharedPtr >	pFields
	)

Interface function to initialise the advection object.

Parameters

pSession	Session configuration data.
pFields	Array of ExpList objects.

Definition at line 57 of file Advection.cpp.

{
    v_InitObject(pSession, pFields);
}

References v_InitObject().

◆ SetBaseFlow()

void Nektar::SolverUtils::Advection::SetBaseFlow	(	const Array< OneD, Array< OneD, NekDouble > > &	inarray,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields
	)

inline

Set the base flow used for linearised advection objects.

Parameters

inarray Vector to use as baseflow

Definition at line 143 of file Advection.h.

    {
        v_SetBaseFlow(inarray, fields);
    }

References v_SetBaseFlow().

◆ SetFluxVector() [1/2]

void Nektar::SolverUtils::Advection::SetFluxVector ( AdvectionFluxVecCB fluxVector )

inline

Set the flux vector callback function.

Parameters

fluxVector The callback function to override.

Definition at line 133 of file Advection.h.

    {
        m_fluxVector = fluxVector;
    }

References m_fluxVector.

◆ SetFluxVector() [2/2]

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::SolverUtils::Advection::SetFluxVector	(	FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Set the flux vector callback function.

This routine is a utility function to avoid the explicit use of std::bind. A function and object can be passed to this function instead.

Definition at line 112 of file Advection.h.

    {
        m_fluxVector =
            std::bind(func, obj, std::placeholders::_1, std::placeholders::_2);
    }

References m_fluxVector.

◆ SetRiemannSolver()

void Nektar::SolverUtils::Advection::SetRiemannSolver ( RiemannSolverSharedPtr riemann )

inline

Set a Riemann solver object for this advection object.

Parameters

riemann The RiemannSolver object.

Definition at line 123 of file Advection.h.

    {
        m_riemann = riemann;
    }

References m_riemann.

◆ v_Advect()

virtual SOLVER_UTILS_EXPORT void Nektar::SolverUtils::Advection::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`
	)

protectedpure virtual

Advects a vector field.

Implemented in Nektar::SolverUtils::AdvectionNonConservative, Nektar::SolverUtils::AdvectionWeakDG, Nektar::SolverUtils::AdvectionFR, Nektar::AdjointAdvection, Nektar::AlternateSkewAdvection, Nektar::LinearisedAdvection, Nektar::NavierStokesAdvection, Nektar::NoAdvection, Nektar::SkewSymmetricAdvection, and Nektar::SolverUtils::Advection3DHomogeneous1D.

Referenced by Advect().

◆ v_InitObject()

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

protectedvirtual

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 in Nektar::SolverUtils::Advection3DHomogeneous1D, Nektar::SolverUtils::AdvectionFR, Nektar::SolverUtils::AdvectionNonConservative, Nektar::SolverUtils::AdvectionWeakDG, Nektar::AlternateSkewAdvection, Nektar::LinearisedAdvection, Nektar::NavierStokesAdvection, Nektar::NoAdvection, and Nektar::SkewSymmetricAdvection.

Definition at line 299 of file Advection.cpp.

{
    m_spaceDim = pFields[0]->GetCoordim(0);
 
    if (pSession->DefinesSolverInfo("HOMOGENEOUS"))
    {
        std::string HomoStr = pSession->GetSolverInfo("HOMOGENEOUS");
        if (HomoStr == "HOMOGENEOUS1D" || HomoStr == "Homogeneous1D" ||
            HomoStr == "1D" || HomoStr == "Homo1D" ||
            HomoStr == "HOMOGENEOUS2D" || HomoStr == "Homogeneous2D" ||
            HomoStr == "2D" || HomoStr == "Homo2D")
        {
            m_spaceDim++;
        }
        else
        {
            NEKERROR(ErrorUtil::efatal,
                     "Only 1D homogeneous dimension supported.");
        }
    }
}

References Nektar::ErrorUtil::efatal, m_spaceDim, and NEKERROR.

Referenced by InitObject(), Nektar::SolverUtils::AdvectionFR::v_InitObject(), Nektar::SolverUtils::AdvectionNonConservative::v_InitObject(), Nektar::SolverUtils::AdvectionWeakDG::v_InitObject(), Nektar::LinearisedAdvection::v_InitObject(), Nektar::NavierStokesAdvection::v_InitObject(), and Nektar::SkewSymmetricAdvection::v_InitObject().

◆ v_SetBaseFlow()

void Nektar::SolverUtils::Advection::v_SetBaseFlow	(	const Array< OneD, Array< OneD, NekDouble > > &	inarray,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields
	)

protectedvirtual

Overrides the base flow used during linearised advection.

Reimplemented in Nektar::LinearisedAdvection.

Definition at line 326 of file Advection.cpp.

{
    boost::ignore_unused(inarray, fields);
    NEKERROR(ErrorUtil::efatal,
             "A baseflow is not appropriate for this advection type.");
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by SetBaseFlow().

Member Data Documentation

◆ m_fluxVector

AdvectionFluxVecCB Nektar::SolverUtils::Advection::m_fluxVector

protected

Callback function to the flux vector (set when advection is in conservative form).

Definition at line 170 of file Advection.h.

Referenced by Nektar::SolverUtils::AdvectionWeakDG::AdvectVolumeFlux(), SetFluxVector(), Nektar::SolverUtils::AdvectionFR::v_Advect(), and Nektar::SolverUtils::Advection3DHomogeneous1D::v_Advect().

◆ m_riemann

RiemannSolverSharedPtr Nektar::SolverUtils::Advection::m_riemann

protected

Riemann solver for DG-type schemes.

Definition at line 172 of file Advection.h.

Referenced by Nektar::SolverUtils::AdvectionWeakDG::AdvectTraceFlux(), SetRiemannSolver(), Nektar::SolverUtils::AdvectionFR::v_Advect(), and Nektar::SolverUtils::Advection3DHomogeneous1D::v_InitObject().

◆ m_spaceDim

int Nektar::SolverUtils::Advection::m_spaceDim

protected

Storage for space dimension. Used for homogeneous extension.

Definition at line 174 of file Advection.h.

Referenced by Nektar::SolverUtils::AdvectionWeakDG::AdvectCoeffs(), Nektar::SolverUtils::AdvectionWeakDG::AdvectTraceFlux(), Nektar::SolverUtils::AdvectionFR::v_Advect(), and v_InitObject().

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~Advection()

Member Function Documentation

◆ AddTraceJacToMat() [1/2]

◆ AddTraceJacToMat() [2/2]

◆ Advect()

◆ CalcJacobTraceInteg()

◆ InitObject()

◆ SetBaseFlow()

◆ SetFluxVector() [1/2]

◆ SetFluxVector() [2/2]

◆ SetRiemannSolver()

◆ v_Advect()

◆ v_InitObject()

◆ v_SetBaseFlow()

Member Data Documentation

◆ m_fluxVector

◆ m_riemann

◆ m_spaceDim