#include <LinearisedAdvection.h>

Inheritance diagram for Nektar::LinearisedAdvection:

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...

Protected Member Functions
DNekBlkMatSharedPtr	GetFloquetBlockMatrix (FloquetMatType mattype, bool UseContCoeffs=false) const

DNekBlkMatSharedPtr	GenFloquetBlockMatrix (FloquetMatType mattype, bool UseContCoeffs=false) const

	LinearisedAdvection ()

	~LinearisedAdvection () override

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...

void	v_SetBaseFlow (const Array< OneD, Array< OneD, NekDouble > > &inarray, const Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
	Overrides the base flow used during linearised advection. More...

void	UpdateBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble time)

void	UpdateGradBase (const int var, const MultiRegions::ExpListSharedPtr &field)

void	DFT (const std::string file, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)

void	ImportFldBase (std::string pInfile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, int slice)
	Import Base flow. More...

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
LibUtilities::SessionReaderSharedPtr	m_session

int	m_spacedim

int	m_expdim

Array< OneD, Array< OneD, NekDouble > >	m_baseflow
	Storage for base flow. More...

Array< OneD, Array< OneD, NekDouble > >	m_gradBase

int	m_start
	number of slices More...

int	m_skip

int	m_slices

NekDouble	m_period
	period length More...

int	m_isperiodic

int	m_interporder

Array< OneD, Array< OneD, NekDouble > >	m_interp
	interpolation vector More...

LibUtilities::NektarFFTSharedPtr	m_FFT
	auxiliary variables More...

Array< OneD, NekDouble >	m_tmpIN

Array< OneD, NekDouble >	m_tmpOUT

bool	m_useFFTW

bool	m_singleMode
	flag to determine if use single mode or not More...

bool	m_halfMode
	flag to determine if use half mode or not More...

bool	m_multipleModes
	flag to determine if use multiple mode or not More...

FloquetBlockMatrixMapShPtr	m_FloquetBlockMat

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...

Private Types
enum	FloquetMatType { eForwardsCoeff , eForwardsPhys }

enum	HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
	Parameter for homogeneous expansions. More...

typedef std::map< FloquetMatType, DNekBlkMatSharedPtr >	FloquetBlockMatrixMap
	A map between matrix keys and their associated block matrices. More...

typedef std::shared_ptr< FloquetBlockMatrixMap >	FloquetBlockMatrixMapShPtr
	A shared pointer to a BlockMatrixMap. More...

Private Attributes
bool	m_useFFT
	flag to determine if use or not the FFT for transformations More...

enum HomogeneousType	m_HomogeneousType

NekDouble	m_LhomX
	physical length in X direction (if homogeneous) More...

NekDouble	m_LhomY
	physical length in Y direction (if homogeneous) More...

NekDouble	m_LhomZ
	physical length in Z direction (if homogeneous) More...

int	m_npointsX
	number of points in X direction (if homogeneous) More...

int	m_npointsY
	number of points in Y direction (if homogeneous) More...

int	m_npointsZ
	number of points in Z direction (if homogeneous) More...

int	m_HomoDirec
	number of homogenous directions More...

int	m_NumMode
	Mode to use in case of single mode analysis. More...

SpatialDomains::BoundaryConditionsSharedPtr	m_boundaryConditions

Friends
class	MemoryManager< LinearisedAdvection >

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::Advection
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)

Detailed Description

Definition at line 44 of file LinearisedAdvection.h.

Member Typedef Documentation

◆ FloquetBlockMatrixMap

typedef std::map<FloquetMatType, DNekBlkMatSharedPtr> Nektar::LinearisedAdvection::FloquetBlockMatrixMap

private

A map between matrix keys and their associated block matrices.

Definition at line 54 of file LinearisedAdvection.h.

◆ FloquetBlockMatrixMapShPtr

typedef std::shared_ptr<FloquetBlockMatrixMap> Nektar::LinearisedAdvection::FloquetBlockMatrixMapShPtr

private

A shared pointer to a BlockMatrixMap.

Definition at line 56 of file LinearisedAdvection.h.

Member Enumeration Documentation

◆ FloquetMatType

enum Nektar::LinearisedAdvection::FloquetMatType

private

Enumerator
eForwardsCoeff
eForwardsPhys

Definition at line 46 of file LinearisedAdvection.h.

    {
        eForwardsCoeff,
        eForwardsPhys
    };

◆ HomogeneousType

enum Nektar::LinearisedAdvection::HomogeneousType

private

Parameter for homogeneous expansions.

Enumerator
eHomogeneous1D
eHomogeneous2D
eHomogeneous3D
eNotHomogeneous

Definition at line 146 of file LinearisedAdvection.h.

    {
        eHomogeneous1D,
        eHomogeneous2D,
        eHomogeneous3D,
        eNotHomogeneous
    };

Constructor & Destructor Documentation

◆ LinearisedAdvection()

Nektar::LinearisedAdvection::LinearisedAdvection ( )

protected

Constructor. Creates ...

Parameters

param

Definition at line 55 of file LinearisedAdvection.cpp.

                                         : Advection()
{
}

◆ ~LinearisedAdvection()

Nektar::LinearisedAdvection::~LinearisedAdvection ( )

overrideprotected

Definition at line 264 of file LinearisedAdvection.cpp.

265{

266}

Member Function Documentation

◆ create()

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

inlinestatic

Creates an instance of this class.

Definition at line 62 of file LinearisedAdvection.h.

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

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

◆ DFT()

void Nektar::LinearisedAdvection::DFT	(	const std::string	file,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields
	)

protected

Definition at line 667 of file LinearisedAdvection.cpp.

{
    size_t ConvectedFields = m_baseflow.size() - 1;
    size_t npoints         = m_baseflow[0].size();
    m_interp = Array<OneD, Array<OneD, NekDouble>>(ConvectedFields);
 
    for (size_t i = 0; i < ConvectedFields; ++i)
    {
        m_interp[i] = Array<OneD, NekDouble>(npoints * m_slices, 0.0);
    }
 
    // Import the slides into auxiliary vector
    // The base flow should be stored in the form "filename_%d.ext"
    // A subdirectory can also be included, such as "dir/filename_%d.ext"
    size_t found = file.find("%d");
    ASSERTL0(found != string::npos &&
                 file.find("%d", found + 1) == string::npos,
             "Since N_slices is specified, the filename provided for function "
             "'BaseFlow' must include exactly one instance of the format "
             "specifier '%d', to index the time-slices.");
    size_t nstart = m_start;
    for (size_t i = nstart; i < nstart + m_slices * m_skip; i += m_skip)
    {
        boost::format filename(file);
        filename % i;
        ImportFldBase(filename.str(), pFields, (i - nstart) / m_skip);
        if (m_session->GetComm()->GetRank() == 0)
        {
            cout << "read base flow file " << filename.str() << endl;
        }
    }
    if (!m_isperiodic)
    {
        return;
    }
 
    // Discrete Fourier Transform of the fields
    for (size_t k = 0; k < ConvectedFields; ++k)
    {
#ifdef NEKTAR_USING_FFTW
 
        // Discrete Fourier Transform using FFTW
        Array<OneD, NekDouble> fft_in(npoints * m_slices);
        Array<OneD, NekDouble> fft_out(npoints * m_slices);
 
        Array<OneD, NekDouble> m_tmpIN(m_slices);
        Array<OneD, NekDouble> m_tmpOUT(m_slices);
 
        // Shuffle the data
        for (int j = 0; j < m_slices; ++j)
        {
            Vmath::Vcopy(npoints, &m_interp[k][j * npoints], 1, &(fft_in[j]),
                         m_slices);
        }
 
        m_FFT = LibUtilities::GetNektarFFTFactory().CreateInstance("NekFFTW",
                                                                   m_slices);
 
        // FFT Transform
        for (size_t i = 0; i < npoints; i++)
        {
            m_FFT->FFTFwdTrans(m_tmpIN  = fft_in + i * m_slices,
                               m_tmpOUT = fft_out + i * m_slices);
        }
 
        // Reshuffle data
        for (int s = 0; s < m_slices; ++s)
        {
            Vmath::Vcopy(npoints, &fft_out[s], m_slices,
                         &m_interp[k][s * npoints], 1);
        }
 
        Vmath::Zero(fft_in.size(), &fft_in[0], 1);
        Vmath::Zero(fft_out.size(), &fft_out[0], 1);
#else
        // Discrete Fourier Transform using MVM
        DNekBlkMatSharedPtr blkmat;
        blkmat = GetFloquetBlockMatrix(eForwardsPhys);
 
        int nrows = blkmat->GetRows();
        int ncols = blkmat->GetColumns();
 
        Array<OneD, NekDouble> sortedinarray(ncols);
        Array<OneD, NekDouble> sortedoutarray(nrows);
 
        // Shuffle the data
        for (int j = 0; j < m_slices; ++j)
        {
            Vmath::Vcopy(npoints, &m_interp[k][j * npoints], 1,
                         &(sortedinarray[j]), m_slices);
        }
 
        // Create NekVectors from the given data arrays
        NekVector<NekDouble> in(ncols, sortedinarray, eWrapper);
        NekVector<NekDouble> out(nrows, sortedoutarray, eWrapper);
 
        // Perform matrix-vector multiply.
        out = (*blkmat) * in;
 
        // Reshuffle data
        for (int s = 0; s < m_slices; ++s)
        {
            Vmath::Vcopy(npoints, &sortedoutarray[s], m_slices,
                         &m_interp[k][s * npoints], 1);
        }
 
        for (size_t r = 0; r < sortedinarray.size(); ++r)
        {
            sortedinarray[0]  = 0;
            sortedoutarray[0] = 0;
        }
 
#endif
    }
}

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), eForwardsPhys, Nektar::eWrapper, CellMLToNektar.pycml::format, GetFloquetBlockMatrix(), Nektar::LibUtilities::GetNektarFFTFactory(), ImportFldBase(), m_baseflow, m_FFT, m_interp, m_isperiodic, m_session, m_skip, m_slices, m_start, m_tmpIN, m_tmpOUT, Vmath::Vcopy(), and Vmath::Zero().

Referenced by v_InitObject().

◆ GenFloquetBlockMatrix()

DNekBlkMatSharedPtr Nektar::LinearisedAdvection::GenFloquetBlockMatrix	(	FloquetMatType	mattype,
		bool	UseContCoeffs = `false`
	)		const

protected

◆ GetFloquetBlockMatrix()

DNekBlkMatSharedPtr Nektar::LinearisedAdvection::GetFloquetBlockMatrix	(	FloquetMatType	mattype,
		bool	UseContCoeffs = `false`
	)		const

protected

Definition at line 627 of file LinearisedAdvection.cpp.

{
    DNekMatSharedPtr loc_mat;
    DNekBlkMatSharedPtr BlkMatrix;
    size_t n_exp = 0;
 
    n_exp = m_baseflow[0].size(); // will operatore on m_phys
 
    Array<OneD, unsigned int> nrows(n_exp);
    Array<OneD, unsigned int> ncols(n_exp);
 
    nrows = Array<OneD, unsigned int>(n_exp, m_slices);
    ncols = Array<OneD, unsigned int>(n_exp, m_slices);
 
    MatrixStorage blkmatStorage = eDIAGONAL;
    BlkMatrix = MemoryManager<DNekBlkMat>::AllocateSharedPtr(nrows, ncols,
                                                             blkmatStorage);
 
    const LibUtilities::PointsKey Pkey(m_slices,
                                       LibUtilities::eFourierEvenlySpaced);
    const LibUtilities::BasisKey BK(LibUtilities::eFourier, m_slices, Pkey);
    StdRegions::StdSegExp StdSeg(BK);
 
    StdRegions::StdMatrixKey matkey(StdRegions::eFwdTrans,
                                    StdSeg.DetShapeType(), StdSeg);
 
    loc_mat = StdSeg.GetStdMatrix(matkey);
 
    // set up array of block matrices.
    for (size_t i = 0; i < n_exp; ++i)
    {
        BlkMatrix->SetBlock(i, i, loc_mat);
    }
 
    return BlkMatrix;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::eDIAGONAL, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::StdRegions::eFwdTrans, Nektar::StdRegions::StdExpansion::GetStdMatrix(), m_baseflow, and m_slices.

Referenced by DFT().

◆ ImportFldBase()

void Nektar::LinearisedAdvection::ImportFldBase	(	std::string	pInfile,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		int	pSlice
	)

protected

Import Base flow.

Import field from infile and load into m_fields. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Parameters

pInFile	Filename to read.
pFields	Array of expansion lists

Definition at line 416 of file LinearisedAdvection.cpp.

{
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble>> FieldData;
 
    size_t nqtot = m_baseflow[0].size();
    Array<OneD, NekDouble> tmp_coeff(pFields[0]->GetNcoeffs(), 0.0);
 
    size_t numexp = pFields[0]->GetExpSize();
    Array<OneD, int> ElementGIDs(numexp);
 
    // Define list of global element ids
    for (size_t i = 0; i < numexp; ++i)
    {
        ElementGIDs[i] = pFields[0]->GetExp(i)->GetGeom()->GetGlobalID();
    }
 
    // Get Homogeneous
    LibUtilities::FieldIOSharedPtr fld =
        LibUtilities::FieldIO::CreateForFile(m_session, pInfile);
    fld->Import(pInfile, FieldDef, FieldData,
                LibUtilities::NullFieldMetaDataMap, ElementGIDs);
 
    size_t nSessionVar     = m_session->GetVariables().size();
    size_t nSessionConvVar = nSessionVar - 1;
    size_t nFileVar        = FieldDef[0]->m_fields.size();
 
    std::unordered_map<int, int> zIdToPlane;
    if (m_singleMode || m_halfMode)
    {
        zIdToPlane[0] = 0;
    }
 
    for (size_t j = 0; j < nFileVar; ++j)
    {
        size_t k = 0;
        for (; k < nSessionConvVar; ++k)
        {
            if (m_session->GetVariable(k) == FieldDef[0]->m_fields[j])
            {
                break;
            }
        }
        if (k == nSessionConvVar)
        {
            continue;
        }
        for (size_t i = 0; i < FieldDef.size(); ++i)
        {
            pFields[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                            FieldDef[i]->m_fields[j], tmp_coeff,
                                            zIdToPlane);
        }
 
        if (m_singleMode || m_halfMode)
        {
            pFields[j]->GetPlane(0)->BwdTrans(tmp_coeff, m_baseflow[k]);
 
            if (m_singleMode)
            {
                // copy the bwd trans into the second plane for single
                // Mode Analysis
                int ncplane = (pFields[0]->GetNpoints()) / m_npointsZ;
                Vmath::Vcopy(ncplane, &m_baseflow[k][0], 1,
                             &m_baseflow[k][ncplane], 1);
            }
        }
        else // fully 3D base flow - put in physical space.
        {
            bool oldwavespace = pFields[j]->GetWaveSpace();
            pFields[j]->SetWaveSpace(false);
            pFields[j]->BwdTrans(tmp_coeff, m_baseflow[k]);
            pFields[j]->SetWaveSpace(oldwavespace);
        }
    }
 
    // If time-periodic, put loaded data into the slice storage.
    if (m_slices > 1)
    {
        for (size_t i = 0; i < nSessionConvVar; ++i)
        {
            Vmath::Vcopy(nqtot, &m_baseflow[i][0], 1,
                         &m_interp[i][pSlice * nqtot], 1);
        }
    }
}

References Nektar::LibUtilities::FieldIO::CreateForFile(), m_baseflow, m_halfMode, m_interp, m_npointsZ, m_session, m_singleMode, m_slices, Nektar::LibUtilities::NullFieldMetaDataMap, and Vmath::Vcopy().

Referenced by DFT(), and v_InitObject().

◆ UpdateBase()

void Nektar::LinearisedAdvection::UpdateBase	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		const NekDouble	time
	)

protected

Definition at line 505 of file LinearisedAdvection.cpp.

{
    int npoints = m_baseflow[0].size();
    if (m_isperiodic)
    {
        NekDouble BetaT = 2 * M_PI * fmod(time, m_period) / m_period;
        NekDouble phase;
        Array<OneD, NekDouble> auxiliary(npoints);
 
        Vmath::Vcopy(npoints, &inarray[0], 1, &outarray[0], 1);
        Vmath::Svtvp(npoints, cos(0.5 * m_slices * BetaT), &inarray[npoints], 1,
                     &outarray[0], 1, &outarray[0], 1);
 
        for (int i = 2; i < m_slices; i += 2)
        {
            phase = (i >> 1) * BetaT;
 
            Vmath::Svtvp(npoints, cos(phase), &inarray[i * npoints], 1,
                         &outarray[0], 1, &outarray[0], 1);
            Vmath::Svtvp(npoints, -sin(phase), &inarray[(i + 1) * npoints], 1,
                         &outarray[0], 1, &outarray[0], 1);
        }
    }
    else
    {
        NekDouble x = time;
        x           = x / m_period * (m_slices - 1);
        int ix      = x;
        if (ix < 0)
        {
            ix = 0;
        }
        if (ix > m_slices - 2)
        {
            ix = m_slices - 2;
        }
        int padleft = m_interporder / 2 - 1;
        if (padleft > ix)
        {
            padleft = ix;
        }
        int padright = m_interporder - 1 - padleft;
        if (padright > m_slices - 1 - ix)
        {
            padright = m_slices - 1 - ix;
        }
        padleft = m_interporder - 1 - padright;
        Array<OneD, NekDouble> coeff(m_interporder, 1.);
        for (int i = 0; i < m_interporder; ++i)
        {
            for (int j = 0; j < m_interporder; ++j)
            {
                if (i != j)
                {
                    coeff[i] *= (x - ix + padleft - (NekDouble)j) /
                                ((NekDouble)i - (NekDouble)j);
                }
            }
        }
        Vmath::Zero(npoints, &outarray[0], 1);
        for (int i = ix - padleft; i < ix + padright + 1; ++i)
        {
            Vmath::Svtvp(npoints, coeff[i - ix + padleft],
                         &inarray[i * npoints], 1, &outarray[0], 1,
                         &outarray[0], 1);
        }
    }
}

References m_baseflow, m_interporder, m_isperiodic, m_period, m_slices, Vmath::Svtvp(), Vmath::Vcopy(), and Vmath::Zero().

Referenced by Nektar::AdjointAdvection::v_Advect(), and v_Advect().

◆ UpdateGradBase()

void Nektar::LinearisedAdvection::UpdateGradBase	(	const int	var,
		const MultiRegions::ExpListSharedPtr &	field
	)

protected

Definition at line 576 of file LinearisedAdvection.cpp.

{
    int nBaseDerivs = (m_halfMode || m_singleMode) ? 2 : m_spacedim;
    switch (m_spacedim)
    {
        case 1: // 1D
        {
            field->PhysDeriv(m_baseflow[var],
                             m_gradBase[var * nBaseDerivs + 0]);
        }
        break;
        case 2: // 2D
        {
            field->PhysDeriv(m_baseflow[var], m_gradBase[var * nBaseDerivs + 0],
                             m_gradBase[var * nBaseDerivs + 1]);
        }
        break;
        case 3:
        {
            if (m_halfMode) // can assume W = 0 and  d/dz == 0
            {
                if (var < 2)
                {
                    field->PhysDeriv(m_baseflow[var],
                                     m_gradBase[var * nBaseDerivs + 0],
                                     m_gradBase[var * nBaseDerivs + 1]);
                }
            }
            else if (m_singleMode) // single mode where d/dz = 0
            {
                field->PhysDeriv(m_baseflow[var],
                                 m_gradBase[var * nBaseDerivs + 0],
                                 m_gradBase[var * nBaseDerivs + 1]);
            }
            else
            {
                // Differentiate base flow in physical space
                bool oldwavespace = field->GetWaveSpace();
                field->SetWaveSpace(false);
                field->PhysDeriv(m_baseflow[var],
                                 m_gradBase[var * nBaseDerivs + 0],
                                 m_gradBase[var * nBaseDerivs + 1],
                                 m_gradBase[var * nBaseDerivs + 2]);
                field->SetWaveSpace(oldwavespace);
            }
        }
        break;
    }
}

References FilterPython_Function::field, m_baseflow, m_gradBase, m_halfMode, m_singleMode, and m_spacedim.

Referenced by Nektar::AdjointAdvection::v_Advect(), v_Advect(), v_InitObject(), and v_SetBaseFlow().

◆ v_Advect()

void Nektar::LinearisedAdvection::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 270 of file LinearisedAdvection.cpp.

{
    ASSERTL1(nConvectiveFields == inarray.size(),
             "Number of convective fields and Inarray are not compatible");
 
    size_t nPointsTot  = fields[0]->GetNpoints();
    size_t ndim        = advVel.size();
    size_t nBaseDerivs = (m_halfMode || m_singleMode) ? 2 : m_spacedim;
    size_t nDerivs     = (m_halfMode) ? 2 : m_spacedim;
 
    Array<OneD, Array<OneD, NekDouble>> velocity(ndim);
    for (size_t i = 0; i < ndim; ++i)
    {
        if (fields[i]->GetWaveSpace() && !m_singleMode && !m_halfMode)
        {
            velocity[i] = Array<OneD, NekDouble>(nPointsTot, 0.0);
            fields[i]->HomogeneousBwdTrans(nPointsTot, advVel[i], velocity[i]);
        }
        else
        {
            velocity[i] = advVel[i];
        }
    }
 
    Array<OneD, Array<OneD, NekDouble>> grad(nDerivs);
    for (size_t i = 0; i < nDerivs; ++i)
    {
        grad[i] = Array<OneD, NekDouble>(nPointsTot);
    }
 
    // Evaluation of the base flow for periodic cases
    if (m_slices > 1)
    {
        for (size_t i = 0; i < ndim; ++i)
        {
            UpdateBase(m_interp[i], m_baseflow[i], time);
            UpdateGradBase(i, fields[i]);
        }
    }
 
    // Evaluate the linearised advection term
    for (size_t i = 0; i < (size_t)nConvectiveFields; ++i)
    {
        // Calculate gradient
        switch (nDerivs)
        {
            case 1:
            {
                fields[i]->PhysDeriv(inarray[i], grad[0]);
            }
            break;
            case 2:
            {
                fields[i]->PhysDeriv(inarray[i], grad[0], grad[1]);
            }
            break;
            case 3:
            {
                fields[i]->PhysDeriv(inarray[i], grad[0], grad[1], grad[2]);
                if (m_multipleModes)
                {
                    // transform gradients into physical Fourier space
                    fields[i]->HomogeneousBwdTrans(nPointsTot, grad[0],
                                                   grad[0]);
                    fields[i]->HomogeneousBwdTrans(nPointsTot, grad[1],
                                                   grad[1]);
                    fields[i]->HomogeneousBwdTrans(nPointsTot, grad[2],
                                                   grad[2]);
                }
            }
            break;
        }
 
        // Calculate U_j du'_i/dx_j
        Vmath::Vmul(nPointsTot, grad[0], 1, m_baseflow[0], 1, outarray[i], 1);
        for (size_t j = 1; j < nDerivs; ++j)
        {
            Vmath::Vvtvp(nPointsTot, grad[j], 1, m_baseflow[j], 1, outarray[i],
                         1, outarray[i], 1);
        }
 
        // Add u'_j dU_i/dx_j
        size_t lim = (m_halfMode || m_singleMode) ? 2 : ndim;
        if (m_halfMode && i == 2)
        {
            lim = 0;
        }
        for (size_t j = 0; j < lim; ++j)
        {
            Vmath::Vvtvp(nPointsTot, m_gradBase[i * nBaseDerivs + j], 1,
                         velocity[j], 1, outarray[i], 1, outarray[i], 1);
        }
 
        if (m_multipleModes)
        {
            fields[i]->HomogeneousFwdTrans(nPointsTot, outarray[i],
                                           outarray[i]);
        }
        Vmath::Neg(nPointsTot, outarray[i], 1);
    }
}

References ASSERTL1, m_baseflow, m_gradBase, m_halfMode, m_interp, m_multipleModes, m_singleMode, m_slices, m_spacedim, Vmath::Neg(), UpdateBase(), UpdateGradBase(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_InitObject()

void Nektar::LinearisedAdvection::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 59 of file LinearisedAdvection.cpp.

{
    Advection::v_InitObject(pSession, pFields);
 
    m_session = pSession;
    m_boundaryConditions =
        MemoryManager<SpatialDomains::BoundaryConditions>::AllocateSharedPtr(
            m_session, pFields[0]->GetGraph());
    m_spacedim = pFields[0]->GetGraph()->GetSpaceDimension();
    m_expdim   = pFields[0]->GetGraph()->GetMeshDimension();
 
    // Setting parameters for homogeneous problems
    m_HomoDirec       = 0;
    m_useFFT          = false;
    m_HomogeneousType = eNotHomogeneous;
    m_singleMode      = false;
    m_halfMode        = false;
    m_multipleModes   = false;
 
    if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
    {
        std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
        m_spacedim          = 3;
 
        if ((HomoStr == "HOMOGENEOUS1D") || (HomoStr == "Homogeneous1D") ||
            (HomoStr == "1D") || (HomoStr == "Homo1D"))
        {
            m_HomogeneousType = eHomogeneous1D;
            m_LhomZ           = m_session->GetParameter("LZ");
            m_HomoDirec       = 1;
 
            ASSERTL0(m_session->DefinesSolverInfo("ModeType"),
                     "Need to specify ModeType as HalfMode,SingleMode or "
                     "MultipleModes");
 
            m_session->MatchSolverInfo("ModeType", "SingleMode", m_singleMode,
                                       false);
            m_session->MatchSolverInfo("ModeType", "HalfMode", m_halfMode,
                                       false);
            m_session->MatchSolverInfo("ModeType", "MultipleModes",
                                       m_multipleModes, false);
 
            if (m_singleMode)
            {
                m_npointsZ = 2;
            }
            else if (m_halfMode)
            {
                m_npointsZ = 1;
            }
            else if (m_multipleModes)
            {
                m_npointsZ = m_session->GetParameter("HomModesZ");
            }
        }
 
        if ((HomoStr == "HOMOGENEOUS2D") || (HomoStr == "Homogeneous2D") ||
            (HomoStr == "2D") || (HomoStr == "Homo2D"))
        {
            m_HomogeneousType = eHomogeneous2D;
            m_session->LoadParameter("HomModesY", m_npointsY);
            m_session->LoadParameter("LY", m_LhomY);
            m_session->LoadParameter("HomModesZ", m_npointsZ);
            m_session->LoadParameter("LZ", m_LhomZ);
            m_HomoDirec = 2;
        }
 
        if ((HomoStr == "HOMOGENEOUS3D") || (HomoStr == "Homogeneous3D") ||
            (HomoStr == "3D") || (HomoStr == "Homo3D"))
        {
            m_HomogeneousType = eHomogeneous3D;
            m_session->LoadParameter("HomModesX", m_npointsX);
            m_session->LoadParameter("LX", m_LhomX);
            m_session->LoadParameter("HomModesY", m_npointsY);
            m_session->LoadParameter("LY", m_LhomY);
            m_session->LoadParameter("HomModesZ", m_npointsZ);
            m_session->LoadParameter("LZ", m_LhomZ);
            m_HomoDirec = 3;
        }
 
        if (m_session->DefinesSolverInfo("USEFFT"))
        {
            m_useFFT = true;
        }
    }
    else
    {
        m_npointsZ = 1; // set to default value so can use to identify 2d or 3D
                        // (homogeneous) expansions
    }
 
    size_t nvar = m_session->GetVariables().size();
    m_baseflow  = Array<OneD, Array<OneD, NekDouble>>(nvar);
    for (size_t i = 0; i < nvar; ++i)
    {
        m_baseflow[i] = Array<OneD, NekDouble>(pFields[i]->GetTotPoints(), 0.0);
    }
 
    size_t nBaseDerivs = (m_halfMode || m_singleMode) ? 2 : m_spacedim;
    m_gradBase = Array<OneD, Array<OneD, NekDouble>>(nvar * nBaseDerivs);
    for (size_t i = 0; i < nvar; ++i)
    {
        for (size_t j = 0; j < nBaseDerivs; ++j)
        {
            m_gradBase[i * nBaseDerivs + j] =
                Array<OneD, NekDouble>(pFields[i]->GetTotPoints(), 0.0);
        }
    }
 
    ASSERTL0(m_session->DefinesFunction("BaseFlow"),
             "Base flow must be defined for linearised forms.");
    string file = m_session->GetFunctionFilename("BaseFlow", 0);
 
    // Periodic base flows
    if (m_session->DefinesParameter("N_slices"))
    {
        m_session->LoadParameter("N_slices", m_slices);
        if (m_slices > 1)
        {
            ASSERTL0(m_session->GetFunctionType("BaseFlow", 0) ==
                         LibUtilities::eFunctionTypeFile,
                     "Base flow should be a sequence of files.");
            m_session->LoadParameter("BaseFlow_interporder", m_interporder, 0);
            ASSERTL0(m_interporder <= m_slices,
                     "BaseFlow_interporder should be smaller than or equal to "
                     "N_slices.");
            m_isperiodic = m_interporder < 2;
            m_session->LoadParameter("N_start", m_start, 0);
            m_session->LoadParameter("N_skip", m_skip, 1);
            DFT(file, pFields);
        }
        else
        {
            ASSERTL0(false, "Number of slices must be a positive number "
                            "greater than 1");
        }
    }
    // Steady base-flow
    else
    {
        m_slices = 1;
 
        // BaseFlow from file
        if (m_session->GetFunctionType("BaseFlow", m_session->GetVariable(0)) ==
            LibUtilities::eFunctionTypeFile)
        {
            ImportFldBase(file, pFields, 1);
        }
        // analytic base flow
        else
        {
            size_t nq = pFields[0]->GetNpoints();
            Array<OneD, NekDouble> x0(nq);
            Array<OneD, NekDouble> x1(nq);
            Array<OneD, NekDouble> x2(nq);
 
            // get the coordinates (assuming all fields have the same
            // discretisation)
            pFields[0]->GetCoords(x0, x1, x2);
 
            for (size_t i = 0; i < pFields.size(); i++)
            {
                LibUtilities::EquationSharedPtr ifunc =
                    m_session->GetFunction("BaseFlow", i);
 
                ifunc->Evaluate(x0, x1, x2, m_baseflow[i]);
            }
        }
    }
 
    for (size_t i = 0; i < nvar; ++i)
    {
        UpdateGradBase(i, pFields[i]);
    }
 
    if (m_session->DefinesParameter("period"))
    {
        m_period = m_session->GetParameter("period");
    }
    else
    {
        m_period =
            (m_session->GetParameter("TimeStep") * m_slices) / (m_slices - 1.);
    }
    if (m_session->GetComm()->GetRank() == 0)
    {
        cout << "baseflow info : interpolation order " << m_interporder
             << ", period " << m_period << ", periodicity ";
        if (m_isperiodic)
        {
            cout << "yes\n";
        }
        else
        {
            cout << "no\n";
        }
        cout << "baseflow info : files from " << m_start << " to "
             << (m_start + (m_slices - 1) * m_skip) << " (skip " << m_skip
             << ") with " << (m_slices - (m_interporder > 1))
             << " time intervals" << endl;
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, DFT(), Nektar::LibUtilities::eFunctionTypeFile, eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, eNotHomogeneous, ImportFldBase(), m_baseflow, m_boundaryConditions, m_expdim, m_gradBase, m_halfMode, m_HomoDirec, m_HomogeneousType, m_interporder, m_isperiodic, m_LhomX, m_LhomY, m_LhomZ, m_multipleModes, m_npointsX, m_npointsY, m_npointsZ, m_period, m_session, m_singleMode, m_skip, m_slices, m_spacedim, m_start, m_useFFT, UpdateGradBase(), and Nektar::SolverUtils::Advection::v_InitObject().

◆ v_SetBaseFlow()

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

overrideprotectedvirtual

Overrides the base flow used during linearised advection.

Reimplemented from Nektar::SolverUtils::Advection.

Definition at line 379 of file LinearisedAdvection.cpp.

{
    if (m_session->GetSolverInfo("EqType") == "UnsteadyNavierStokes")
    {
        // The SFD method is only applied to the velocity variables in
        // incompressible
        ASSERTL1(inarray.size() == (m_baseflow.size() - 1),
                 "Number of base flow variables does not match what is "
                 "expected.");
    }
    else
    {
        ASSERTL1(
            inarray.size() == (m_baseflow.size()),
            "Number of base flow variables does not match what is expected.");
    }
 
    size_t npts = inarray[0].size();
 
    for (size_t i = 0; i < inarray.size(); ++i)
    {
        ASSERTL1(npts == m_baseflow[i].size(),
                 "Size of base flow array does not match expected.");
        Vmath::Vcopy(npts, inarray[i], 1, m_baseflow[i], 1);
        UpdateGradBase(i, fields[i]);
    }
}

References ASSERTL1, m_baseflow, m_session, UpdateGradBase(), and Vmath::Vcopy().

Friends And Related Function Documentation

◆ MemoryManager< LinearisedAdvection >

friend class MemoryManager< LinearisedAdvection >

friend

Definition at line 56 of file LinearisedAdvection.h.

Member Data Documentation

◆ className

string Nektar::LinearisedAdvection::className

static

Initial value:

=
    SolverUtils::GetAdvectionFactory().RegisterCreatorFunction(
        "Linearised", LinearisedAdvection::create,
        "Linearised Non-Conservative")

Name of class.

Definition at line 67 of file LinearisedAdvection.h.

◆ m_baseflow

Array<OneD, Array<OneD, NekDouble> > Nektar::LinearisedAdvection::m_baseflow

protected

Storage for base flow.

Definition at line 76 of file LinearisedAdvection.h.

Referenced by DFT(), GetFloquetBlockMatrix(), ImportFldBase(), UpdateBase(), UpdateGradBase(), Nektar::AdjointAdvection::v_Advect(), v_Advect(), v_InitObject(), and v_SetBaseFlow().

◆ m_boundaryConditions

SpatialDomains::BoundaryConditionsSharedPtr Nektar::LinearisedAdvection::m_boundaryConditions

private

Definition at line 171 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_expdim

int Nektar::LinearisedAdvection::m_expdim

protected

Definition at line 73 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_FFT

LibUtilities::NektarFFTSharedPtr Nektar::LinearisedAdvection::m_FFT

protected

auxiliary variables

Definition at line 90 of file LinearisedAdvection.h.

Referenced by DFT().

◆ m_FloquetBlockMat

FloquetBlockMatrixMapShPtr Nektar::LinearisedAdvection::m_FloquetBlockMat

protected

Definition at line 105 of file LinearisedAdvection.h.

◆ m_gradBase

Array<OneD, Array<OneD, NekDouble> > Nektar::LinearisedAdvection::m_gradBase

protected

Definition at line 77 of file LinearisedAdvection.h.

Referenced by UpdateGradBase(), Nektar::AdjointAdvection::v_Advect(), v_Advect(), and v_InitObject().

◆ m_halfMode

bool Nektar::LinearisedAdvection::m_halfMode

protected

flag to determine if use half mode or not

Definition at line 97 of file LinearisedAdvection.h.

Referenced by ImportFldBase(), UpdateGradBase(), Nektar::AdjointAdvection::v_Advect(), v_Advect(), and v_InitObject().

◆ m_HomoDirec

int Nektar::LinearisedAdvection::m_HomoDirec

private

number of homogenous directions

Definition at line 167 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_HomogeneousType

enum HomogeneousType Nektar::LinearisedAdvection::m_HomogeneousType

private

Definition at line 157 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_interp

Array<OneD, Array<OneD, NekDouble> > Nektar::LinearisedAdvection::m_interp

protected

interpolation vector

Definition at line 88 of file LinearisedAdvection.h.

Referenced by DFT(), ImportFldBase(), Nektar::AdjointAdvection::v_Advect(), and v_Advect().

◆ m_interporder

int Nektar::LinearisedAdvection::m_interporder

protected

Definition at line 86 of file LinearisedAdvection.h.

Referenced by UpdateBase(), and v_InitObject().

◆ m_isperiodic

int Nektar::LinearisedAdvection::m_isperiodic

protected

Definition at line 85 of file LinearisedAdvection.h.

Referenced by DFT(), UpdateBase(), and v_InitObject().

◆ m_LhomX

NekDouble Nektar::LinearisedAdvection::m_LhomX

private

physical length in X direction (if homogeneous)

Definition at line 159 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_LhomY

NekDouble Nektar::LinearisedAdvection::m_LhomY

private

physical length in Y direction (if homogeneous)

Definition at line 160 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_LhomZ

NekDouble Nektar::LinearisedAdvection::m_LhomZ

private

physical length in Z direction (if homogeneous)

Definition at line 161 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_multipleModes

bool Nektar::LinearisedAdvection::m_multipleModes

protected

flag to determine if use multiple mode or not

Definition at line 99 of file LinearisedAdvection.h.

Referenced by Nektar::AdjointAdvection::v_Advect(), v_Advect(), and v_InitObject().

◆ m_npointsX

int Nektar::LinearisedAdvection::m_npointsX

private

number of points in X direction (if homogeneous)

Definition at line 163 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_npointsY

int Nektar::LinearisedAdvection::m_npointsY

private

number of points in Y direction (if homogeneous)

Definition at line 164 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_npointsZ

int Nektar::LinearisedAdvection::m_npointsZ

private

number of points in Z direction (if homogeneous)

Definition at line 165 of file LinearisedAdvection.h.

Referenced by ImportFldBase(), and v_InitObject().

◆ m_NumMode

int Nektar::LinearisedAdvection::m_NumMode

private

Mode to use in case of single mode analysis.

Definition at line 169 of file LinearisedAdvection.h.

◆ m_period

NekDouble Nektar::LinearisedAdvection::m_period

protected

period length

Definition at line 84 of file LinearisedAdvection.h.

Referenced by UpdateBase(), Nektar::AdjointAdvection::v_Advect(), and v_InitObject().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::LinearisedAdvection::m_session

protected

Definition at line 70 of file LinearisedAdvection.h.

Referenced by DFT(), ImportFldBase(), v_InitObject(), and v_SetBaseFlow().

◆ m_singleMode

bool Nektar::LinearisedAdvection::m_singleMode

protected

flag to determine if use single mode or not

Definition at line 95 of file LinearisedAdvection.h.

Referenced by ImportFldBase(), UpdateGradBase(), Nektar::AdjointAdvection::v_Advect(), v_Advect(), and v_InitObject().

◆ m_skip

int Nektar::LinearisedAdvection::m_skip

protected

Definition at line 81 of file LinearisedAdvection.h.

Referenced by DFT(), and v_InitObject().

◆ m_slices

int Nektar::LinearisedAdvection::m_slices

protected

Definition at line 82 of file LinearisedAdvection.h.

Referenced by DFT(), GetFloquetBlockMatrix(), ImportFldBase(), UpdateBase(), Nektar::AdjointAdvection::v_Advect(), v_Advect(), and v_InitObject().

◆ m_spacedim

int Nektar::LinearisedAdvection::m_spacedim

protected

Definition at line 72 of file LinearisedAdvection.h.

Referenced by UpdateGradBase(), Nektar::AdjointAdvection::v_Advect(), v_Advect(), and v_InitObject().

◆ m_start

int Nektar::LinearisedAdvection::m_start

protected

number of slices

Definition at line 80 of file LinearisedAdvection.h.

Referenced by DFT(), and v_InitObject().

◆ m_tmpIN

Array<OneD, NekDouble> Nektar::LinearisedAdvection::m_tmpIN

protected

Definition at line 91 of file LinearisedAdvection.h.

Referenced by DFT().

◆ m_tmpOUT

Array<OneD, NekDouble> Nektar::LinearisedAdvection::m_tmpOUT

protected

Definition at line 92 of file LinearisedAdvection.h.

Referenced by DFT().

◆ m_useFFT

bool Nektar::LinearisedAdvection::m_useFFT

private

flag to determine if use or not the FFT for transformations

Definition at line 155 of file LinearisedAdvection.h.

Referenced by v_InitObject().

◆ m_useFFTW

bool Nektar::LinearisedAdvection::m_useFFTW

protected

Definition at line 93 of file LinearisedAdvection.h.

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ FloquetBlockMatrixMap

◆ FloquetBlockMatrixMapShPtr

Member Enumeration Documentation

◆ FloquetMatType

◆ HomogeneousType

Constructor & Destructor Documentation

◆ LinearisedAdvection()

◆ ~LinearisedAdvection()

Member Function Documentation

◆ create()

◆ DFT()

◆ GenFloquetBlockMatrix()

◆ GetFloquetBlockMatrix()

◆ ImportFldBase()

◆ UpdateBase()

◆ UpdateGradBase()

◆ v_Advect()

◆ v_InitObject()

◆ v_SetBaseFlow()

Friends And Related Function Documentation

◆ MemoryManager< LinearisedAdvection >

Member Data Documentation

◆ className

◆ m_baseflow

◆ m_boundaryConditions

◆ m_expdim

◆ m_FFT

◆ m_FloquetBlockMat

◆ m_gradBase

◆ m_halfMode

◆ m_HomoDirec

◆ m_HomogeneousType

◆ m_interp

◆ m_interporder

◆ m_isperiodic

◆ m_LhomX

◆ m_LhomY

◆ m_LhomZ

◆ m_multipleModes

◆ m_npointsX

◆ m_npointsY

◆ m_npointsZ

◆ m_NumMode

◆ m_period

◆ m_session

◆ m_singleMode

◆ m_skip

◆ m_slices

◆ m_spacedim

◆ m_start

◆ m_tmpIN

◆ m_tmpOUT

◆ m_useFFT

◆ m_useFFTW