Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Attributes | Friends | List of all members
Nektar::LinearisedAdvection Class Reference

#include <LinearisedAdvection.h>

Inheritance diagram for Nektar::LinearisedAdvection:
Inheritance graph
[legend]
Collaboration diagram for Nektar::LinearisedAdvection:
Collaboration graph
[legend]

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 ()
 
virtual ~LinearisedAdvection ()
 
virtual void v_InitObject (LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
 Initialises the advection object. More...
 
virtual 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)
 Advects a vector field. More...
 
virtual 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...
 
void UpdateBase (const NekDouble m_slices, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble m_time, const NekDouble m_period)
 
void UpdateGradBase (const int var, const MultiRegions::ExpListSharedPtr &field)
 
void DFT (const std::string file, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const NekDouble m_slices)
 
void ImportFldBase (std::string pInfile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, int slice)
 Import Base flow. 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_slices
 number of slices More...
 
NekDouble m_period
 period length More...
 
Array< OneD, Array< OneD,
NekDouble > > 
m_interp
 interpolation vector More...
 
LibUtilities::NektarFFTSharedPtr m_FFT
 auxiliary variables More...
 
Array< OneD, NekDoublem_tmpIN
 
Array< OneD, NekDoublem_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 boost::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
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...
 

Detailed Description

Definition at line 46 of file LinearisedAdvection.h.

Member Typedef Documentation

A map between matrix keys and their associated block matrices.

Definition at line 56 of file LinearisedAdvection.h.

A shared pointer to a BlockMatrixMap.

Definition at line 58 of file LinearisedAdvection.h.

Member Enumeration Documentation

Enumerator
eForwardsCoeff 
eForwardsPhys 

Definition at line 48 of file LinearisedAdvection.h.

Parameter for homogeneous expansions.

Enumerator
eHomogeneous1D 
eHomogeneous2D 
eHomogeneous3D 
eNotHomogeneous 

Definition at line 154 of file LinearisedAdvection.h.

Constructor & Destructor Documentation

Nektar::LinearisedAdvection::LinearisedAdvection ( )
protected

Constructor. Creates ...

Parameters
param

Definition at line 55 of file LinearisedAdvection.cpp.

55  :
56  Advection()
57 {
58 }
Nektar::LinearisedAdvection::~LinearisedAdvection ( )
protectedvirtual

Definition at line 242 of file LinearisedAdvection.cpp.

243 {
244 }

Member Function Documentation

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

Creates an instance of this class.

Definition at line 64 of file LinearisedAdvection.h.

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

65  {
67  }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
void Nektar::LinearisedAdvection::DFT ( const std::string  file,
Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields,
const NekDouble  m_slices 
)
protected

Definition at line 603 of file LinearisedAdvection.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), eForwardsPhys, Nektar::eWrapper, GetFloquetBlockMatrix(), Nektar::LibUtilities::GetNektarFFTFactory(), ImportFldBase(), m_baseflow, m_FFT, m_interp, m_slices, m_tmpIN, m_tmpOUT, Vmath::Smul(), Vmath::Vcopy(), and Vmath::Zero().

Referenced by v_InitObject().

606 {
607  int ConvectedFields = m_baseflow.num_elements()-1;
608  int npoints = m_baseflow[0].num_elements();
609  m_interp = Array<OneD, Array<OneD, NekDouble> > (ConvectedFields);
610 
611  for (int i = 0; i < ConvectedFields; ++i)
612  {
613  m_interp[i] = Array<OneD,NekDouble>(npoints*m_slices, 0.0);
614  }
615 
616  // Import the slides into auxiliary vector
617  // The base flow should be stored in the form "filename_%d.ext"
618  // A subdirectory can also be included, such as "dir/filename_%d.ext"
619  size_t found = file.find("%d");
620  ASSERTL0(found != string::npos && file.find("%d", found+1) == string::npos,
621  "Since N_slices is specified, the filename provided for function "
622  "'BaseFlow' must include exactly one instance of the format "
623  "specifier '%d', to index the time-slices.");
624  char* buffer = new char[file.length() + 8];
625  for (int i = 0; i < m_slices; ++i)
626  {
627  sprintf(buffer, file.c_str(), i);
628  ImportFldBase(buffer,pFields,i);
629  }
630  delete[] buffer;
631 
632 
633  // Discrete Fourier Transform of the fields
634  for(int k=0; k< ConvectedFields;++k)
635  {
636 #ifdef NEKTAR_USING_FFTW
637 
638  //Discrete Fourier Transform using FFTW
639  Array<OneD, NekDouble> fft_in(npoints*m_slices);
640  Array<OneD, NekDouble> fft_out(npoints*m_slices);
641 
642  Array<OneD, NekDouble> m_tmpIN(m_slices);
643  Array<OneD, NekDouble> m_tmpOUT(m_slices);
644 
645  //Shuffle the data
646  for(int j= 0; j < m_slices; ++j)
647  {
648  Vmath::Vcopy(npoints,&m_interp[k][j*npoints],1,&(fft_in[j]),m_slices);
649  }
650 
651  m_FFT = LibUtilities::GetNektarFFTFactory().CreateInstance("NekFFTW", m_slices);
652 
653  //FFT Transform
654  for(int i=0; i<npoints; i++)
655  {
656  m_FFT->FFTFwdTrans(m_tmpIN =fft_in + i*m_slices, m_tmpOUT =fft_out + i*m_slices);
657 
658  }
659 
660  //Reshuffle data
661  for(int s = 0; s < m_slices; ++s)
662  {
663  Vmath::Vcopy(npoints,&fft_out[s],m_slices,&m_interp[k][s*npoints],1);
664 
665  }
666 
667  Vmath::Zero(fft_in.num_elements(),&fft_in[0],1);
668  Vmath::Zero(fft_out.num_elements(),&fft_out[0],1);
669 #else
670  //Discrete Fourier Transform using MVM
671  DNekBlkMatSharedPtr blkmat;
673 
674  int nrows = blkmat->GetRows();
675  int ncols = blkmat->GetColumns();
676 
677  Array<OneD, NekDouble> sortedinarray(ncols);
678  Array<OneD, NekDouble> sortedoutarray(nrows);
679 
680  //Shuffle the data
681  for(int j= 0; j < m_slices; ++j)
682  {
683  Vmath::Vcopy(npoints,&m_interp[k][j*npoints],1,&(sortedinarray[j]),m_slices);
684  }
685 
686  // Create NekVectors from the given data arrays
687  NekVector<NekDouble> in (ncols,sortedinarray,eWrapper);
688  NekVector<NekDouble> out(nrows,sortedoutarray,eWrapper);
689 
690  // Perform matrix-vector multiply.
691  out = (*blkmat)*in;
692 
693  //Reshuffle data
694  for(int s = 0; s < m_slices; ++s)
695  {
696  Vmath::Vcopy(npoints,&sortedoutarray[s],m_slices,&m_interp[k][s*npoints],1);
697  }
698 
699  for(int r=0; r<sortedinarray.num_elements();++r)
700  {
701  sortedinarray[0]=0;
702  sortedoutarray[0]=0;
703  }
704 
705 #endif
706 
707  //scaling of the Fourier coefficients
708  NekDouble j=-1;
709  for (int i = 2; i < m_slices; i += 2)
710  {
711  Vmath::Smul(2*npoints,j,&m_interp[k][i*npoints],1,&m_interp[k][i*npoints],1);
712  j=-j;
713 
714  }
715 
716  }
717 
718 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
Array< OneD, NekDouble > m_tmpIN
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
LibUtilities::NektarFFTSharedPtr m_FFT
auxiliary variables
void ImportFldBase(std::string pInfile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, int slice)
Import Base flow.
array buffer
Definition: GsLib.hpp:60
int m_slices
number of slices
Array< OneD, NekDouble > m_tmpOUT
NektarFFTFactory & GetNektarFFTFactory()
Definition: NektarFFT.cpp:69
Array< OneD, Array< OneD, NekDouble > > m_interp
interpolation vector
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:213
double NekDouble
DNekBlkMatSharedPtr GetFloquetBlockMatrix(FloquetMatType mattype, bool UseContCoeffs=false) const
boost::shared_ptr< DNekBlkMat > DNekBlkMatSharedPtr
Definition: NekTypeDefs.hpp:72
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:373
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
DNekBlkMatSharedPtr Nektar::LinearisedAdvection::GenFloquetBlockMatrix ( FloquetMatType  mattype,
bool  UseContCoeffs = false 
) const
protected
DNekBlkMatSharedPtr Nektar::LinearisedAdvection::GetFloquetBlockMatrix ( FloquetMatType  mattype,
bool  UseContCoeffs = false 
) const
protected

Definition at line 564 of file LinearisedAdvection.cpp.

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

565 {
566  DNekMatSharedPtr loc_mat;
567  DNekBlkMatSharedPtr BlkMatrix;
568  int n_exp = 0;
569 
570  n_exp = m_baseflow[0].num_elements(); // will operatore on m_phys
571 
572  Array<OneD,unsigned int> nrows(n_exp);
573  Array<OneD,unsigned int> ncols(n_exp);
574 
575  nrows = Array<OneD, unsigned int>(n_exp,m_slices);
576  ncols = Array<OneD, unsigned int>(n_exp,m_slices);
577 
578  MatrixStorage blkmatStorage = eDIAGONAL;
579  BlkMatrix = MemoryManager<DNekBlkMat>
580  ::AllocateSharedPtr(nrows,ncols,blkmatStorage);
581 
582 
583  const LibUtilities::PointsKey Pkey(m_slices,LibUtilities::eFourierEvenlySpaced);
584  const LibUtilities::BasisKey BK(LibUtilities::eFourier,m_slices,Pkey);
585  StdRegions::StdSegExp StdSeg(BK);
586 
587  StdRegions::StdMatrixKey matkey(StdRegions::eFwdTrans,
588  StdSeg.DetShapeType(),
589  StdSeg);
590 
591  loc_mat = StdSeg.GetStdMatrix(matkey);
592 
593  // set up array of block matrices.
594  for(int i = 0; i < n_exp; ++i)
595  {
596  BlkMatrix->SetBlock(i,i,loc_mat);
597  }
598 
599  return BlkMatrix;
600 }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
int m_slices
number of slices
Fourier Expansion .
Definition: BasisType.h:52
boost::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:70
1D Evenly-spaced points using Fourier Fit
Definition: PointsType.h:66
boost::shared_ptr< DNekBlkMat > DNekBlkMatSharedPtr
Definition: NekTypeDefs.hpp:72
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
pInFileFilename to read.
pFieldsArray of expansion lists

Definition at line 397 of file LinearisedAdvection.cpp.

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

Referenced by DFT(), and v_InitObject().

401 {
402  std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
403  std::vector<std::vector<NekDouble> > FieldData;
404 
405  int nqtot = m_baseflow[0].num_elements();
406  Array<OneD, NekDouble> tmp_coeff(pFields[0]->GetNcoeffs(), 0.0);
407 
408  int numexp = pFields[0]->GetExpSize();
409  Array<OneD,int> ElementGIDs(numexp);
410 
411  // Define list of global element ids
412  for(int i = 0; i < numexp; ++i)
413  {
414  ElementGIDs[i] = pFields[0]->GetExp(i)->GetGeom()->GetGlobalID();
415  }
416 
417  //Get Homogeneous
419  m_session, pInfile);
420  fld->Import(pInfile, FieldDef, FieldData,
422  ElementGIDs);
423 
424  int nSessionVar = m_session->GetVariables().size();
425  int nSessionConvVar = nSessionVar - 1;
426  int nFileVar = FieldDef[0]->m_fields.size();
427  int nFileConvVar = nFileVar - 1; // Ignore pressure
428  if (m_halfMode)
429  {
430  ASSERTL0(nFileVar == 3, "For half mode, expect 2D2C base flow.");
431  nFileConvVar = 2;
432  }
433 
434  for(int j = 0; j < nFileConvVar; ++j)
435  {
436  for(int i = 0; i < FieldDef.size(); ++i)
437  {
438  bool flag = FieldDef[i]->m_fields[j] ==
439  m_session->GetVariable(j);
440 
441  ASSERTL0(flag, (std::string("Order of ") + pInfile
442  + std::string(" data and that defined in "
443  "the session file differs")).c_str());
444 
445  pFields[j]->ExtractDataToCoeffs(
446  FieldDef[i],
447  FieldData[i],
448  FieldDef[i]->m_fields[j],
449  tmp_coeff);
450  }
451 
452  if(m_singleMode || m_halfMode)
453  {
454  pFields[j]->GetPlane(0)->BwdTrans(tmp_coeff, m_baseflow[j]);
455 
456  if(m_singleMode)
457  {
458  //copy the bwd trans into the second plane for single
459  //Mode Analysis
460  int ncplane=(pFields[0]->GetNpoints())/m_npointsZ;
461  Vmath::Vcopy(ncplane,&m_baseflow[j][0],1,&m_baseflow[j][ncplane],1);
462  }
463  }
464  else // fully 3D base flow - put in physical space.
465  {
466  bool oldwavespace = pFields[j]->GetWaveSpace();
467  pFields[j]->SetWaveSpace(false);
468  pFields[j]->BwdTrans(tmp_coeff, m_baseflow[j]);
469  pFields[j]->SetWaveSpace(oldwavespace);
470  }
471  }
472 
473  // Zero unused fields (e.g. w in a 2D2C base flow).
474  for (int j = nFileConvVar; j < nSessionConvVar; ++j)
475  {
476  Vmath::Fill(nqtot, 0.0, m_baseflow[j], 1);
477  }
478 
479  // If time-periodic, put loaded data into the slice storage.
480  if(m_session->DefinesParameter("N_slices"))
481  {
482  for(int i = 0; i < nSessionConvVar; ++i)
483  {
484  Vmath::Vcopy(nqtot, &m_baseflow[i][0], 1, &m_interp[i][pSlice*nqtot], 1);
485  }
486  }
487 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
bool m_singleMode
flag to determine if use single mode or not
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:46
Array< OneD, Array< OneD, NekDouble > > m_interp
interpolation vector
int m_npointsZ
number of points in Z direction (if homogeneous)
boost::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:309
LibUtilities::SessionReaderSharedPtr m_session
static boost::shared_ptr< FieldIO > CreateForFile(const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
Construct a FieldIO object for a given input filename.
Definition: FieldIO.cpp:212
bool m_halfMode
flag to determine if use half mode or not
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
static FieldMetaDataMap NullFieldMetaDataMap
Definition: FieldIO.h:55
void Nektar::LinearisedAdvection::UpdateBase ( const NekDouble  m_slices,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const NekDouble  m_time,
const NekDouble  m_period 
)
protected

Definition at line 490 of file LinearisedAdvection.cpp.

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

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

496 {
497  int npoints = m_baseflow[0].num_elements();
498  NekDouble BetaT = 2*M_PI*fmod (m_time, m_period) / m_period;
499  NekDouble phase;
500  Array<OneD, NekDouble> auxiliary(npoints);
501 
502  Vmath::Vcopy(npoints,&inarray[0],1,&outarray[0],1);
503  Vmath::Svtvp(npoints, cos(0.5*m_slices*BetaT),&inarray[npoints],1,&outarray[0],1,&outarray[0],1);
504 
505  for (int i = 2; i < m_slices; i += 2)
506  {
507  phase = (i>>1) * BetaT;
508 
509  Vmath::Svtvp(npoints, cos(phase),&inarray[i*npoints],1,&outarray[0],1,&outarray[0],1);
510  Vmath::Svtvp(npoints, -sin(phase), &inarray[(i+1)*npoints], 1, &outarray[0], 1,&outarray[0],1);
511  }
512 
513 }
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:485
int m_slices
number of slices
double NekDouble
NekDouble m_period
period length
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061
void Nektar::LinearisedAdvection::UpdateGradBase ( const int  var,
const MultiRegions::ExpListSharedPtr field 
)
protected

Definition at line 515 of file LinearisedAdvection.cpp.

References m_baseflow, m_gradBase, m_halfMode, m_singleMode, and m_spacedim.

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

518 {
519  int nBaseDerivs = (m_halfMode || m_singleMode) ? 2 : m_spacedim;
520  switch(m_spacedim)
521  {
522  case 1: // 1D
523  {
524  field->PhysDeriv(m_baseflow[var], m_gradBase[var*nBaseDerivs + 0]);
525  }
526  break;
527  case 2: //2D
528  {
529  field->PhysDeriv(m_baseflow[var], m_gradBase[var*nBaseDerivs + 0],
530  m_gradBase[var*nBaseDerivs + 1]);
531  }
532  break;
533  case 3:
534  {
535  if(m_halfMode) // can assume W = 0 and d/dz == 0
536  {
537  if( var < 2)
538  {
539  field->PhysDeriv(m_baseflow[var],
540  m_gradBase[var*nBaseDerivs + 0],
541  m_gradBase[var*nBaseDerivs + 1]);
542  }
543  }
544  else if(m_singleMode) // single mode where d/dz = 0
545  {
546  field->PhysDeriv(m_baseflow[var], m_gradBase[var*nBaseDerivs + 0],
547  m_gradBase[var*nBaseDerivs + 1]);
548  }
549  else
550  {
551  // Differentiate base flow in physical space
552  bool oldwavespace = field->GetWaveSpace();
553  field->SetWaveSpace(false);
554  field->PhysDeriv(m_baseflow[var], m_gradBase[var*nBaseDerivs + 0],
555  m_gradBase[var*nBaseDerivs + 1],
556  m_gradBase[var*nBaseDerivs + 2]);
557  field->SetWaveSpace(oldwavespace);
558  }
559  }
560  break;
561  }
562 }
bool m_singleMode
flag to determine if use single mode or not
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
bool m_halfMode
flag to determine if use half mode or not
Array< OneD, Array< OneD, NekDouble > > m_gradBase
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 
)
protectedvirtual

Advects a vector field.

Implements Nektar::SolverUtils::Advection.

Reimplemented in Nektar::AdjointAdvection.

Definition at line 249 of file LinearisedAdvection.cpp.

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

258 {
259  ASSERTL1(nConvectiveFields == inarray.num_elements(),
260  "Number of convective fields and Inarray are not compatible");
261 
262  int nPointsTot = fields[0]->GetNpoints();
263  int ndim = advVel.num_elements();
264  int nBaseDerivs = (m_halfMode || m_singleMode) ? 2 : m_spacedim;
265  int nDerivs = (m_halfMode) ? 2 : m_spacedim;
266 
267  Array<OneD, Array<OneD, NekDouble> > velocity(ndim);
268  for(int i = 0; i < ndim; ++i)
269  {
270  if(fields[i]->GetWaveSpace() && !m_singleMode && !m_halfMode)
271  {
272  velocity[i] = Array<OneD, NekDouble>(nPointsTot,0.0);
273  fields[i]->HomogeneousBwdTrans(advVel[i],velocity[i]);
274  }
275  else
276  {
277  velocity[i] = advVel[i];
278  }
279  }
280 
281  Array<OneD, Array<OneD, NekDouble> > grad (nDerivs);
282  for( int i = 0; i < nDerivs; ++i)
283  {
284  grad[i] = Array<OneD, NekDouble> (nPointsTot);
285  }
286 
287  // Evaluation of the base flow for periodic cases
288  if (m_slices > 1)
289  {
290  for (int i = 0; i < ndim; ++i)
291  {
293  time, m_period);
294  UpdateGradBase(i, fields[i]);
295  }
296  }
297 
298  //Evaluate the linearised advection term
299  for( int i = 0; i < ndim; ++i)
300  {
301  // Calculate gradient
302  switch(nDerivs)
303  {
304  case 1:
305  {
306  fields[i]->PhysDeriv(inarray[i], grad[0]);
307  }
308  break;
309  case 2:
310  {
311  fields[i]->PhysDeriv(inarray[i], grad[0], grad[1]);
312  }
313  break;
314  case 3:
315  {
316  fields[i]->PhysDeriv(inarray[i], grad[0], grad[1], grad[2]);
317  if(m_multipleModes)
318  {
319  // transform gradients into physical Fourier space
320  fields[i]->HomogeneousBwdTrans(grad[0], grad[0]);
321  fields[i]->HomogeneousBwdTrans(grad[1], grad[1]);
322  fields[i]->HomogeneousBwdTrans(grad[2], grad[2]);
323  }
324  }
325  break;
326  }
327 
328  // Calculate U_j du'_i/dx_j
329  Vmath::Vmul(nPointsTot,grad[0], 1, m_baseflow[0], 1, outarray[i], 1);
330  for( int j = 1; j < nDerivs; ++j)
331  {
332  Vmath::Vvtvp(nPointsTot,grad[j], 1,
333  m_baseflow[j], 1,
334  outarray[i], 1,
335  outarray[i], 1);
336  }
337 
338  // Add u'_j dU_i/dx_j
339  int lim = (m_halfMode || m_singleMode) ? 2 : ndim;
340  if (m_halfMode && i==2)
341  {
342  lim = 0;
343  }
344  for( int j = 0; j < lim; ++j)
345  {
346  Vmath::Vvtvp(nPointsTot,m_gradBase[i*nBaseDerivs + j], 1,
347  velocity[j], 1,
348  outarray[i], 1,
349  outarray[i], 1);
350  }
351 
352  if(m_multipleModes)
353  {
354  fields[i]->HomogeneousFwdTrans(outarray[i],outarray[i]);
355  }
356  Vmath::Neg(nPointsTot,outarray[i],1);
357  }
358 }
bool m_singleMode
flag to determine if use single mode or not
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:442
int m_slices
number of slices
Array< OneD, Array< OneD, NekDouble > > m_interp
interpolation vector
void UpdateBase(const NekDouble m_slices, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble m_time, const NekDouble m_period)
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:396
NekDouble m_period
period length
bool m_multipleModes
flag to determine if use multiple mode or not
bool m_halfMode
flag to determine if use half mode or not
void UpdateGradBase(const int var, const MultiRegions::ExpListSharedPtr &field)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
Array< OneD, Array< OneD, NekDouble > > m_gradBase
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:183
void Nektar::LinearisedAdvection::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
pSessionSession information.
pFieldsExpansion lists for scalar fields.

Reimplemented from Nektar::SolverUtils::Advection.

Definition at line 61 of file LinearisedAdvection.cpp.

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_LhomX, m_LhomY, m_LhomZ, m_multipleModes, m_npointsX, m_npointsY, m_npointsZ, m_period, m_session, m_singleMode, m_slices, m_spacedim, m_useFFT, UpdateGradBase(), and Nektar::SolverUtils::Advection::v_InitObject().

64 {
65  Advection::v_InitObject(pSession, pFields);
66 
67  m_session = pSession;
69  ::AllocateSharedPtr(m_session, pFields[0]->GetGraph());
70  m_spacedim = pFields[0]->GetGraph()->GetSpaceDimension();
71  m_expdim = pFields[0]->GetGraph()->GetMeshDimension();
72 
73  //Setting parameters for homogeneous problems
74  m_HomoDirec = 0;
75  m_useFFT = false;
77  m_singleMode = false;
78  m_halfMode = false;
79  m_multipleModes = false;
80 
81  if(m_session->DefinesSolverInfo("HOMOGENEOUS"))
82  {
83  std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
84  m_spacedim = 3;
85 
86  if((HomoStr == "HOMOGENEOUS1D")||(HomoStr == "Homogeneous1D")||
87  (HomoStr == "1D")||(HomoStr == "Homo1D"))
88  {
90  m_LhomZ = m_session->GetParameter("LZ");
91  m_HomoDirec = 1;
92 
93  ASSERTL0(m_session->DefinesSolverInfo("ModeType"),
94  "Need to specify ModeType as HalfMode,SingleMode or "
95  "MultipleModes");
96 
97  m_session->MatchSolverInfo("ModeType", "SingleMode",
98  m_singleMode, false);
99  m_session->MatchSolverInfo("ModeType", "HalfMode",
100  m_halfMode, false);
101  m_session->MatchSolverInfo("ModeType", "MultipleModes",
102  m_multipleModes, false);
103 
104  if(m_singleMode)
105  {
106  m_npointsZ = 2;
107  }
108  else if(m_halfMode)
109  {
110  m_npointsZ = 1;
111  }
112  else if(m_multipleModes)
113  {
114  m_npointsZ = m_session->GetParameter("HomModesZ");
115  }
116  }
117 
118  if((HomoStr == "HOMOGENEOUS2D")||(HomoStr == "Homogeneous2D")||
119  (HomoStr == "2D")||(HomoStr == "Homo2D"))
120  {
122  m_session->LoadParameter("HomModesY", m_npointsY);
123  m_session->LoadParameter("LY", m_LhomY);
124  m_session->LoadParameter("HomModesZ", m_npointsZ);
125  m_session->LoadParameter("LZ", m_LhomZ);
126  m_HomoDirec = 2;
127  }
128 
129  if((HomoStr == "HOMOGENEOUS3D")||(HomoStr == "Homogeneous3D")||
130  (HomoStr == "3D")||(HomoStr == "Homo3D"))
131  {
133  m_session->LoadParameter("HomModesX",m_npointsX);
134  m_session->LoadParameter("LX", m_LhomX );
135  m_session->LoadParameter("HomModesY",m_npointsY);
136  m_session->LoadParameter("LY", m_LhomY );
137  m_session->LoadParameter("HomModesZ",m_npointsZ);
138  m_session->LoadParameter("LZ", m_LhomZ );
139  m_HomoDirec = 3;
140  }
141 
142  if(m_session->DefinesSolverInfo("USEFFT"))
143  {
144  m_useFFT = true;
145  }
146  }
147  else
148  {
149  m_npointsZ = 1; // set to default value so can use to identify 2d or 3D (homogeneous) expansions
150  }
151 
152  int nvar = m_session->GetVariables().size();
153  m_baseflow = Array<OneD, Array<OneD, NekDouble> >(nvar);
154  for (int i = 0; i < nvar; ++i)
155  {
156  m_baseflow[i] = Array<OneD, NekDouble>(pFields[i]->GetTotPoints(), 0.0);
157  }
158 
159  int nBaseDerivs = (m_halfMode || m_singleMode) ? 2 : m_spacedim;
160  m_gradBase = Array<OneD, Array<OneD, NekDouble> >(nvar*nBaseDerivs);
161  for (int i = 0; i < nvar; ++i)
162  {
163  for (int j = 0; j < nBaseDerivs; ++j)
164  {
165  m_gradBase[i*nBaseDerivs + j ] = Array<OneD, NekDouble>
166  (pFields[i]->GetTotPoints(), 0.0);
167  }
168  }
169 
170  ASSERTL0(m_session->DefinesFunction("BaseFlow"),
171  "Base flow must be defined for linearised forms.");
172  string file = m_session->GetFunctionFilename("BaseFlow", 0);
173 
174 
175  //Periodic base flows
176  if(m_session->DefinesParameter("N_slices"))
177  {
178  m_session->LoadParameter("N_slices",m_slices);
179  if(m_slices>1)
180  {
181  ASSERTL0(m_session->GetFunctionType("BaseFlow", 0)
183  "Base flow should be a sequence of files.");
184  DFT(file,pFields,m_slices);
185  }
186  else
187  {
188  ASSERTL0(false, "Number of slices must be a positive number "
189  "greater than 1");
190  }
191  }
192  //Steady base-flow
193  else
194  {
195  m_slices=1;
196 
197  //BaseFlow from file
198  if (m_session->GetFunctionType("BaseFlow", m_session->GetVariable(0))
200  {
201  ImportFldBase(file,pFields,1);
202 
203  }
204  //analytic base flow
205  else
206  {
207  int nq = pFields[0]->GetNpoints();
208  Array<OneD,NekDouble> x0(nq);
209  Array<OneD,NekDouble> x1(nq);
210  Array<OneD,NekDouble> x2(nq);
211 
212  // get the coordinates (assuming all fields have the same
213  // discretisation)
214  pFields[0]->GetCoords(x0,x1,x2);
215 
216  for(unsigned int i = 0 ; i < pFields.num_elements(); i++)
217  {
219  = m_session->GetFunction("BaseFlow", i);
220 
221  ifunc->Evaluate(x0,x1,x2,m_baseflow[i]);
222  }
223  }
224  }
225 
226  for (int i = 0; i < nvar; ++i)
227  {
228  UpdateGradBase(i, pFields[i]);
229  }
230 
231  if(m_session->DefinesParameter("period"))
232  {
233  m_period=m_session->GetParameter("period");
234  }
235  else
236  {
237  m_period=(m_session->GetParameter("TimeStep")*m_slices)/(m_slices-1.);
238  }
239 
240 }
enum HomogeneousType m_HomogeneousType
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
int m_HomoDirec
number of homogenous directions
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
bool m_singleMode
flag to determine if use single mode or not
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
void ImportFldBase(std::string pInfile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, int slice)
Import Base flow.
int m_slices
number of slices
void DFT(const std::string file, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const NekDouble m_slices)
int m_npointsZ
number of points in Z direction (if homogeneous)
NekDouble m_period
period length
int m_npointsY
number of points in Y direction (if homogeneous)
boost::shared_ptr< Equation > EquationSharedPtr
bool m_multipleModes
flag to determine if use multiple mode or not
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
NekDouble m_LhomY
physical length in Y direction (if homogeneous)
LibUtilities::SessionReaderSharedPtr m_session
int m_npointsX
number of points in X direction (if homogeneous)
NekDouble m_LhomX
physical length in X direction (if homogeneous)
bool m_halfMode
flag to determine if use half mode or not
void UpdateGradBase(const int var, const MultiRegions::ExpListSharedPtr &field)
NekDouble m_LhomZ
physical length in Z direction (if homogeneous)
bool m_useFFT
flag to determine if use or not the FFT for transformations
Array< OneD, Array< OneD, NekDouble > > m_gradBase
virtual SOLVER_UTILS_EXPORT void v_InitObject(LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields)
Initialises the advection object.
Definition: Advection.cpp:100
void Nektar::LinearisedAdvection::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 from Nektar::SolverUtils::Advection.

Definition at line 360 of file LinearisedAdvection.cpp.

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

363 {
364  if (m_session->GetSolverInfo("EqType") == "UnsteadyNavierStokes")
365  {
366  // The SFD method is only applied to the velocity variables in
367  // incompressible
368  ASSERTL1(inarray.num_elements() == (m_baseflow.num_elements() - 1),
369  "Number of base flow variables does not match what is "
370  "expected.");
371  }
372  else
373  {
374  ASSERTL1(inarray.num_elements() == (m_baseflow.num_elements()),
375  "Number of base flow variables does not match what is expected.");
376  }
377 
378  int npts = inarray[0].num_elements();
379 
380  for (int i = 0; i < inarray.num_elements(); ++i)
381  {
382  ASSERTL1(npts == m_baseflow[i].num_elements(),
383  "Size of base flow array does not match expected.");
384  Vmath::Vcopy(npts, inarray[i], 1, m_baseflow[i], 1);
385  UpdateGradBase(i, fields[i]);
386  }
387 }
Array< OneD, Array< OneD, NekDouble > > m_baseflow
Storage for base flow.
static std::string npts
Definition: InputFld.cpp:43
LibUtilities::SessionReaderSharedPtr m_session
void UpdateGradBase(const int var, const MultiRegions::ExpListSharedPtr &field)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1061

Friends And Related Function Documentation

friend class MemoryManager< LinearisedAdvection >
friend

Definition at line 61 of file LinearisedAdvection.h.

Member Data Documentation

string Nektar::LinearisedAdvection::className
static
Initial value:

Name of class.

Definition at line 69 of file LinearisedAdvection.h.

Array<OneD, Array<OneD, NekDouble> > Nektar::LinearisedAdvection::m_baseflow
protected
SpatialDomains::BoundaryConditionsSharedPtr Nektar::LinearisedAdvection::m_boundaryConditions
private

Definition at line 179 of file LinearisedAdvection.h.

Referenced by v_InitObject().

int Nektar::LinearisedAdvection::m_expdim
protected

Definition at line 75 of file LinearisedAdvection.h.

Referenced by v_InitObject().

LibUtilities::NektarFFTSharedPtr Nektar::LinearisedAdvection::m_FFT
protected

auxiliary variables

Definition at line 88 of file LinearisedAdvection.h.

Referenced by DFT().

FloquetBlockMatrixMapShPtr Nektar::LinearisedAdvection::m_FloquetBlockMat
protected

Definition at line 105 of file LinearisedAdvection.h.

Array<OneD, Array<OneD, NekDouble> > Nektar::LinearisedAdvection::m_gradBase
protected
bool Nektar::LinearisedAdvection::m_halfMode
protected

flag to determine if use half mode or not

Definition at line 95 of file LinearisedAdvection.h.

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

int Nektar::LinearisedAdvection::m_HomoDirec
private

number of homogenous directions

Definition at line 175 of file LinearisedAdvection.h.

Referenced by v_InitObject().

enum HomogeneousType Nektar::LinearisedAdvection::m_HomogeneousType
private

Definition at line 165 of file LinearisedAdvection.h.

Referenced by v_InitObject().

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

interpolation vector

Definition at line 86 of file LinearisedAdvection.h.

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

NekDouble Nektar::LinearisedAdvection::m_LhomX
private

physical length in X direction (if homogeneous)

Definition at line 167 of file LinearisedAdvection.h.

Referenced by v_InitObject().

NekDouble Nektar::LinearisedAdvection::m_LhomY
private

physical length in Y direction (if homogeneous)

Definition at line 168 of file LinearisedAdvection.h.

Referenced by v_InitObject().

NekDouble Nektar::LinearisedAdvection::m_LhomZ
private

physical length in Z direction (if homogeneous)

Definition at line 169 of file LinearisedAdvection.h.

Referenced by v_InitObject().

bool Nektar::LinearisedAdvection::m_multipleModes
protected

flag to determine if use multiple mode or not

Definition at line 97 of file LinearisedAdvection.h.

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

int Nektar::LinearisedAdvection::m_npointsX
private

number of points in X direction (if homogeneous)

Definition at line 171 of file LinearisedAdvection.h.

Referenced by v_InitObject().

int Nektar::LinearisedAdvection::m_npointsY
private

number of points in Y direction (if homogeneous)

Definition at line 172 of file LinearisedAdvection.h.

Referenced by v_InitObject().

int Nektar::LinearisedAdvection::m_npointsZ
private

number of points in Z direction (if homogeneous)

Definition at line 173 of file LinearisedAdvection.h.

Referenced by ImportFldBase(), and v_InitObject().

int Nektar::LinearisedAdvection::m_NumMode
private

Mode to use in case of single mode analysis.

Definition at line 177 of file LinearisedAdvection.h.

NekDouble Nektar::LinearisedAdvection::m_period
protected

period length

Definition at line 84 of file LinearisedAdvection.h.

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

LibUtilities::SessionReaderSharedPtr Nektar::LinearisedAdvection::m_session
protected

Definition at line 72 of file LinearisedAdvection.h.

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

bool Nektar::LinearisedAdvection::m_singleMode
protected

flag to determine if use single mode or not

Definition at line 93 of file LinearisedAdvection.h.

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

int Nektar::LinearisedAdvection::m_slices
protected
int Nektar::LinearisedAdvection::m_spacedim
protected
Array<OneD,NekDouble> Nektar::LinearisedAdvection::m_tmpIN
protected

Definition at line 89 of file LinearisedAdvection.h.

Referenced by DFT().

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

Definition at line 90 of file LinearisedAdvection.h.

Referenced by DFT().

bool Nektar::LinearisedAdvection::m_useFFT
private

flag to determine if use or not the FFT for transformations

Definition at line 163 of file LinearisedAdvection.h.

Referenced by v_InitObject().

bool Nektar::LinearisedAdvection::m_useFFTW
protected

Definition at line 91 of file LinearisedAdvection.h.