#include <Advection3DHomogeneous1D.h>

Inheritance diagram for Nektar::SolverUtils::Advection3DHomogeneous1D:

Collaboration diagram for Nektar::SolverUtils::Advection3DHomogeneous1D:

Static Public Member Functions
static AdvectionSharedPtr	create (std::string advType)

Static Public Attributes
static std::string	type []

Protected Member Functions
	Advection3DHomogeneous1D (std::string advType)
	AdvectionFR uses the Flux Reconstruction (FR) approach to compute the advection term. The implementation is only for segments, quadrilaterals and hexahedra at the moment.
virtual void	v_InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
	Initiliase Advection3DHomogeneous1D objects and store them before starting the time-stepping.
virtual void	v_Advect (const int nConvField, 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)
	Compute the advection operator for a given input inarray and put the result in outarray.

Protected Attributes
std::string	m_advType
SolverUtils::AdvectionSharedPtr	m_planeAdv
int	m_numPoints
int	m_numPointsPlane
int	m_numPlanes
int	m_planeCounter
Array< OneD, unsigned int >	m_planes
Array< OneD, unsigned int >	m_planePos
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_fluxVecStore
Array< OneD, Array< OneD, NekDouble > >	m_inarrayPlane
Array< OneD, Array< OneD, NekDouble > >	m_outarrayPlane
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fieldsPlane
Array< OneD, Array< OneD, NekDouble > >	m_advVelPlane
Array< OneD, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > >	m_fluxVecPlane
Protected Attributes inherited from Nektar::SolverUtils::Advection
AdvectionFluxVecCB	m_fluxVector
	Callback function to the flux vector (set when advection is in conservative form).
RiemannSolverSharedPtr	m_riemann
	Riemann solver for DG-type schemes.
int	m_spaceDim
	Storage for space dimension. Used for homogeneous extension.

Private Member Functions
void	ModifiedFluxVector (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::Advection
SOLVER_UTILS_EXPORT void	InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
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)
template<typename FuncPointerT , typename ObjectPointerT >
void	SetFluxVector (FuncPointerT func, ObjectPointerT obj)
	Set the flux vector callback function.
void	SetRiemannSolver (RiemannSolverSharedPtr riemann)
	Set a Riemann solver object for this advection object.
void	SetFluxVector (AdvectionFluxVecCB fluxVector)
	Set the flux vector callback function.

Detailed Description

Definition at line 48 of file Advection3DHomogeneous1D.h.

Constructor & Destructor Documentation

Nektar::SolverUtils::Advection3DHomogeneous1D::Advection3DHomogeneous1D ( std::string advType )

protected

AdvectionFR uses the Flux Reconstruction (FR) approach to compute the advection term. The implementation is only for segments, quadrilaterals and hexahedra at the moment.

Todo:: Extension to triangles, tetrahedra and other shapes. (Long term objective)

Definition at line 70 of file Advection3DHomogeneous1D.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::SolverUtils::GetAdvectionFactory(), and m_planeAdv.

Referenced by create().

          : m_advType(advType)
        {
            // Strip trailing string "3DHomogeneous1D" to determine 2D advection
            // type, and create an advection object for the plane.
            string advName = advType.substr(0, advType.length()-15);
            m_planeAdv = GetAdvectionFactory().CreateInstance(advName, advName);
        }

Member Function Documentation

static AdvectionSharedPtr Nektar::SolverUtils::Advection3DHomogeneous1D::create ( std::string advType )

inlinestatic

Definition at line 51 of file Advection3DHomogeneous1D.h.

References Advection3DHomogeneous1D().

            {
                return AdvectionSharedPtr(
                    new Advection3DHomogeneous1D(advType));
            }

void Nektar::SolverUtils::Advection3DHomogeneous1D::ModifiedFluxVector	(	const Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &	flux
	)

private

Definition at line 242 of file Advection3DHomogeneous1D.cpp.

References m_fluxVecPlane, m_numPlanes, and m_planeCounter.

Referenced by v_InitObject().

        {
            // Return section of flux vector for this plane.
            outarray = m_fluxVecPlane[m_planeCounter];
            // Increment the plane counter.
            m_planeCounter = (m_planeCounter + 1) % m_numPlanes;
        }

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

protectedvirtual

Compute the advection operator for a given input inarray and put the result in outarray.

Parameters

nConvectiveFields	Number of fields to advect.
fields	Pointer to fields.
advVel	Advection velocities.
inarray	Input which will be advected.
outarray	Computed advection.

Implements Nektar::SolverUtils::Advection.

Definition at line 189 of file Advection3DHomogeneous1D.cpp.

References m_advVelPlane, m_fieldsPlane, m_fluxVecStore, Nektar::SolverUtils::Advection::m_fluxVector, m_inarrayPlane, m_numPlanes, m_numPoints, m_numPointsPlane, m_outarrayPlane, m_planeAdv, m_planePos, and Vmath::Vadd().

        {
            Array<OneD, NekDouble> tmp(m_numPoints), tmp2;
            int nVel = advVel.num_elements();
            // Call solver's flux vector function to compute the flux vector on
            // the entire domain.
            m_fluxVector(inarray, m_fluxVecStore);
            // Loop over each plane.
            for (int i = 0; i < m_numPlanes; ++i)
            {
                // Set up memory references for fields, inarray and outarray for
                // this plane.
                for (int j = 0; j < nConvectiveFields; ++j)
                {
                    m_fieldsPlane  [j] = fields[j]->GetPlane(i);
                    m_inarrayPlane [j] = Array<OneD, NekDouble>(
                        m_numPointsPlane, tmp2 = inarray [j] + m_planePos[i]);
                    m_outarrayPlane[j] = Array<OneD, NekDouble>(
                        m_numPointsPlane, tmp2 = outarray[j] + m_planePos[i]);
                }
                for (int j = 0; j < nVel; ++j)
                {
                    if (advVel[j].num_elements() != 0)
                    {
                        m_advVelPlane[j] = Array<OneD, NekDouble>(
                            m_numPointsPlane, tmp2 = advVel[j] + m_planePos[i]);
                    }
                }
                // Compute advection term for this plane.
                m_planeAdv->Advect(nConvectiveFields, m_fieldsPlane,
                                   m_advVelPlane, m_inarrayPlane,
                                   m_outarrayPlane);
            }
            // Calculate Fourier derivative and add to final result.
            for (int i = 0; i < nConvectiveFields; ++i)
            {
                fields[0]->PhysDeriv(2, m_fluxVecStore[i][2], tmp);
                Vmath::Vadd(m_numPoints, outarray[i], 1, tmp, 1,
                                         outarray[i], 1);
            }
        }

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

protectedvirtual

Initiliase Advection3DHomogeneous1D objects and store them before starting the time-stepping.

Parameters

pSession	Pointer to session reader.
pFields	Pointer to fields.

Reimplemented from Nektar::SolverUtils::Advection.

Definition at line 86 of file Advection3DHomogeneous1D.cpp.

References Nektar::SolverUtils::HomoRSScalar::Exec(), Nektar::SolverUtils::HomoRSVector::Exec(), Nektar::iterator, m_advVelPlane, m_fieldsPlane, m_fluxVecPlane, m_fluxVecStore, m_inarrayPlane, m_numPlanes, m_numPoints, m_numPointsPlane, m_outarrayPlane, m_planeAdv, m_planeCounter, m_planePos, m_planes, Nektar::SolverUtils::Advection::m_riemann, and ModifiedFluxVector().

        {
            int nConvectiveFields = pFields.num_elements();
            Array<OneD, MultiRegions::ExpListSharedPtr> pFields_plane0(
                nConvectiveFields);
            // Initialise the plane advection object.
            for (int i = 0; i < nConvectiveFields; ++i)
            {
                pFields_plane0[i] = pFields[i]->GetPlane(0);
            }
            m_planeAdv->InitObject(pSession, pFields_plane0);
            m_numPoints      = pFields[0]->GetTotPoints();
            m_planes         = pFields[0]->GetZIDs();
            m_numPlanes      = m_planes.num_elements();
            m_numPointsPlane = m_numPoints/m_numPlanes;
            // Set Riemann solver and flux vector callback for this plane.
            m_planeAdv->SetRiemannSolver(m_riemann);
            m_planeAdv->SetFluxVector   (
                &Advection3DHomogeneous1D::ModifiedFluxVector, this);
            m_planeCounter = 0;
            // Override Riemann solver scalar and vector callbacks.
            map<string, RSScalarFuncType>::iterator it1;
            map<string, RSVecFuncType>::iterator it2;
            map<string, RSScalarFuncType> scalars = m_riemann->GetScalars();
            map<string, RSVecFuncType> vectors = m_riemann->GetVectors();
            for (it1 = scalars.begin(); it1 != scalars.end(); ++it1)
            {
                boost::shared_ptr<HomoRSScalar> tmp = MemoryManager<HomoRSScalar>
                    ::AllocateSharedPtr(it1->second, m_numPlanes);
                m_riemann->SetScalar(it1->first, &HomoRSScalar::Exec, tmp);
            }
            for (it2 = vectors.begin(); it2 != vectors.end(); ++it2)
            {
                boost::shared_ptr<HomoRSVector> tmp = MemoryManager<HomoRSVector>
                    ::AllocateSharedPtr(it2->second, m_numPlanes, it2->first);
                m_riemann->SetVector(it2->first, &HomoRSVector::Exec, tmp);
            }
            m_fluxVecStore = Array<OneD, Array<OneD, Array<OneD, NekDouble> > >(
                nConvectiveFields);
            // Set up storage for flux vector.
            for (int i = 0; i < nConvectiveFields; ++i)
            {
                m_fluxVecStore[i] = Array<OneD, Array<OneD, NekDouble> >(3);
                for (int j = 0; j < 3; ++j)
                {
                    m_fluxVecStore[i][j] = Array<OneD, NekDouble>(m_numPoints);
                }
            }
            m_fluxVecPlane = Array<OneD, Array<OneD,
                          Array<OneD, Array<OneD, NekDouble> > > >(m_numPlanes);
            m_fieldsPlane   = Array<OneD, MultiRegions::ExpListSharedPtr>
                                                            (nConvectiveFields);
            m_inarrayPlane  = Array<OneD, Array<OneD, NekDouble> >
                                                            (nConvectiveFields);
            m_outarrayPlane = Array<OneD, Array<OneD, NekDouble> >
                                                            (nConvectiveFields);
            m_planePos      = Array<OneD, unsigned int>     (m_numPlanes);
            m_advVelPlane   = Array<OneD, Array<OneD, NekDouble> > (3);
            // Set up memory reference which links fluxVecPlane to fluxVecStore.
            for (int i = 0; i < m_numPlanes; ++i)
            {
                m_planePos[i] = i * m_numPointsPlane;
                m_fluxVecPlane[i] =
                    Array<OneD, Array<OneD, Array<OneD, NekDouble> > >(
                        nConvectiveFields);
                for (int j = 0; j < nConvectiveFields; ++j)
                {
                    m_fluxVecPlane[i][j] =
                        Array<OneD, Array<OneD, NekDouble> >(3);
                    for (int k = 0; k < 3; ++k)
                    {
                        m_fluxVecPlane[i][j][k] = Array<OneD, NekDouble>(
                            m_numPointsPlane,
                            m_fluxVecStore[j][k] + m_planePos[i]);
                    }
                }
            }
        }

Member Data Documentation

std::string Nektar::SolverUtils::Advection3DHomogeneous1D::m_advType

protected

Definition at line 61 of file Advection3DHomogeneous1D.h.

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::Advection3DHomogeneous1D::m_advVelPlane

protected

Definition at line 73 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::Advection3DHomogeneous1D::m_fieldsPlane

protected

Definition at line 72 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

Array<OneD, Array<OneD, Array<OneD, Array<OneD, NekDouble> > > > Nektar::SolverUtils::Advection3DHomogeneous1D::m_fluxVecPlane

protected

Definition at line 75 of file Advection3DHomogeneous1D.h.

Referenced by ModifiedFluxVector(), and v_InitObject().

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::SolverUtils::Advection3DHomogeneous1D::m_fluxVecStore

protected

Definition at line 69 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::Advection3DHomogeneous1D::m_inarrayPlane

protected

Definition at line 70 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

int Nektar::SolverUtils::Advection3DHomogeneous1D::m_numPlanes

protected

Definition at line 65 of file Advection3DHomogeneous1D.h.

Referenced by ModifiedFluxVector(), v_Advect(), and v_InitObject().

int Nektar::SolverUtils::Advection3DHomogeneous1D::m_numPoints

protected

Definition at line 63 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

int Nektar::SolverUtils::Advection3DHomogeneous1D::m_numPointsPlane

protected

Definition at line 64 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::Advection3DHomogeneous1D::m_outarrayPlane

protected

Definition at line 71 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

SolverUtils::AdvectionSharedPtr Nektar::SolverUtils::Advection3DHomogeneous1D::m_planeAdv

protected

Definition at line 62 of file Advection3DHomogeneous1D.h.

Referenced by Advection3DHomogeneous1D(), v_Advect(), and v_InitObject().

int Nektar::SolverUtils::Advection3DHomogeneous1D::m_planeCounter

protected

Definition at line 66 of file Advection3DHomogeneous1D.h.

Referenced by ModifiedFluxVector(), and v_InitObject().

Array<OneD, unsigned int> Nektar::SolverUtils::Advection3DHomogeneous1D::m_planePos

protected

Definition at line 68 of file Advection3DHomogeneous1D.h.

Referenced by v_Advect(), and v_InitObject().

Array<OneD, unsigned int> Nektar::SolverUtils::Advection3DHomogeneous1D::m_planes

protected

Definition at line 67 of file Advection3DHomogeneous1D.h.

Referenced by v_InitObject().

std::string Nektar::SolverUtils::Advection3DHomogeneous1D::type

static

Initial value:

 {
            GetAdvectionFactory().RegisterCreatorFunction(
                "WeakDG3DHomogeneous1D", Advection3DHomogeneous1D::create),
            GetAdvectionFactory().RegisterCreatorFunction(
                "FRDG3DHomogeneous1D",   Advection3DHomogeneous1D::create),
            GetAdvectionFactory().RegisterCreatorFunction(
                "FRDG3DHomogeneous1D",   Advection3DHomogeneous1D::create),
            GetAdvectionFactory().RegisterCreatorFunction(
                "FRSD3DHomogeneous1D",   Advection3DHomogeneous1D::create),
            GetAdvectionFactory().RegisterCreatorFunction(
                "FRHU3DHomogeneous1D",   Advection3DHomogeneous1D::create),
            GetAdvectionFactory().RegisterCreatorFunction(
                "FRcmin3DHomogeneous1D", Advection3DHomogeneous1D::create),
            GetAdvectionFactory().RegisterCreatorFunction(
                "FRcinf3DHomogeneous1D", Advection3DHomogeneous1D::create)
        }

Definition at line 56 of file Advection3DHomogeneous1D.h.

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation