Nektar++
Classes | Typedefs | Enumerations | Functions | Variables
Nektar::Collections Namespace Reference

Classes

class  BwdTrans_StdMat
 Backward transform operator using standard matrix approach. More...
 
class  BwdTrans_MatrixFree
 Backward transform operator using matrix free operators. More...
 
class  BwdTrans_IterPerExp
 Backward transform operator using default StdRegions operator. More...
 
class  BwdTrans_NoCollection
 Backward transform operator using LocalRegions implementation. More...
 
class  BwdTrans_SumFac_Seg
 Backward transform operator using sum-factorisation (Segment) More...
 
class  BwdTrans_SumFac_Quad
 Backward transform operator using sum-factorisation (Quad) More...
 
class  BwdTrans_SumFac_Tri
 Backward transform operator using sum-factorisation (Tri) More...
 
class  BwdTrans_SumFac_Hex
 Backward transform operator using sum-factorisation (Hex) More...
 
class  BwdTrans_SumFac_Tet
 Backward transform operator using sum-factorisation (Tet) More...
 
class  BwdTrans_SumFac_Prism
 Backward transform operator using sum-factorisation (Prism) More...
 
class  BwdTrans_SumFac_Pyr
 Backward transform operator using sum-factorisation (Pyr) More...
 
class  CoalescedGeomData
 
class  Collection
 Collection. More...
 
class  OpImpTimingKey
 
class  CollectionOptimisation
 
class  Helmholtz_NoCollection
 Helmholtz operator using LocalRegions implementation. More...
 
class  Helmholtz_IterPerExp
 Helmholtz operator using LocalRegions implementation. More...
 
class  Helmholtz_MatrixFree
 Helmholtz operator using matrix free operators. More...
 
class  IProductWRTBase_StdMat
 Inner product operator using standard matrix approach. More...
 
class  IProductWRTBase_MatrixFree
 Inner product operator using operator using matrix free operators. More...
 
class  IProductWRTBase_IterPerExp
 Inner product operator using element-wise operation. More...
 
class  IProductWRTBase_NoCollection
 Inner product operator using original MultiRegions implementation. More...
 
class  IProductWRTBase_SumFac_Seg
 Inner product operator using sum-factorisation (Segment) More...
 
class  IProductWRTBase_SumFac_Quad
 Inner product operator using sum-factorisation (Quad) More...
 
class  IProductWRTBase_SumFac_Tri
 Inner product operator using sum-factorisation (Tri) More...
 
class  IProductWRTBase_SumFac_Hex
 Inner Product operator using sum-factorisation (Hex) More...
 
class  IProductWRTBase_SumFac_Tet
 Inner product operator using sum-factorisation (Tet) More...
 
class  IProductWRTBase_SumFac_Prism
 Inner Product operator using sum-factorisation (Prism) More...
 
class  IProductWRTBase_SumFac_Pyr
 Inner Product operator using sum-factorisation (Pyr) More...
 
class  IProductWRTDerivBase_StdMat
 Inner product WRT deriv base operator using standard matrix approach. More...
 
class  IProductWRTDerivBase_MatrixFree
 Inner product operator using operator using matrix free operators. More...
 
class  IProductWRTDerivBase_IterPerExp
 Inner product WRT deriv base operator using element-wise operation. More...
 
class  IProductWRTDerivBase_NoCollection
 Inner product WRT deriv base operator using LocalRegions implementation. More...
 
class  IProductWRTDerivBase_SumFac_Seg
 Inner product WRT deriv base operator using sum-factorisation (Segment) More...
 
class  IProductWRTDerivBase_SumFac_Quad
 Inner product WRT deriv base operator using sum-factorisation (Quad) More...
 
class  IProductWRTDerivBase_SumFac_Tri
 Inner product WRT deriv base operator using sum-factorisation (Tri) More...
 
class  IProductWRTDerivBase_SumFac_Hex
 Inner product WRT deriv base operator using sum-factorisation (Hex) More...
 
class  IProductWRTDerivBase_SumFac_Tet
 Inner product WRT deriv base operator using sum-factorisation (Tet) More...
 
class  IProductWRTDerivBase_SumFac_Prism
 Inner product WRT deriv base operator using sum-factorisation (Prism) More...
 
class  IProductWRTDerivBase_SumFac_Pyr
 Inner product WRT deriv base operator using sum-factorisation (Pyr) More...
 
class  MatrixFreeBase
 
class  MatrixFreeOneInOneOut
 
class  MatrixFreeMultiInOneOut
 
class  MatrixFreeOneInMultiOut
 
class  Operator
 Base class for operators on a collection of elements. More...
 
class  PhysDeriv_StdMat
 Phys deriv operator using standard matrix approach. More...
 
class  PhysDeriv_MatrixFree
 Phys deriv operator using matrix free operators. More...
 
class  PhysDeriv_IterPerExp
 Phys deriv operator using element-wise operation. More...
 
class  PhysDeriv_NoCollection
 Phys deriv operator using original LocalRegions implementation. More...
 
class  PhysDeriv_SumFac_Seg
 Phys deriv operator using sum-factorisation (Segment) More...
 
class  PhysDeriv_SumFac_Quad
 Phys deriv operator using sum-factorisation (Quad) More...
 
class  PhysDeriv_SumFac_Tri
 Phys deriv operator using sum-factorisation (Tri) More...
 
class  PhysDeriv_SumFac_Hex
 Phys deriv operator using sum-factorisation (Hex) More...
 
class  PhysDeriv_SumFac_Tet
 Phys deriv operator using sum-factorisation (Tet) More...
 
class  PhysDeriv_SumFac_Prism
 Phys deriv operator using sum-factorisation (Prism) More...
 
class  PhysDeriv_SumFac_Pyr
 Phys deriv operator using sum-factorisation (Pyramid) More...
 

Typedefs

using vec_t = simd< NekDouble >
 
typedef std::vector< vec_t, tinysimd::allocator< vec_t > > VecVec_t
 
typedef std::shared_ptr< CoalescedGeomData > CoalescedGeomDataSharedPtr
 
typedef std::vector< Collection > CollectionVector
 
typedef std::shared_ptr< CollectionVector > CollectionVectorSharedPtr
 
typedef bool ExpansionIsNodal
 
typedef std::map< OperatorType, ImplementationType > OperatorImpMap
 
typedef std::shared_ptr< Operator > OperatorSharedPtr
 Shared pointer to an Operator object. More...
 
typedef std::tuple< LibUtilities::ShapeType, OperatorType, ImplementationType, ExpansionIsNodal > OperatorKey
 Key for describing an Operator. More...
 
typedef Nektar::LibUtilities::NekFactory< OperatorKey, Operator, std::vector< StdRegions::StdExpansionSharedPtr >, CoalescedGeomDataSharedPtr, StdRegions::FactorMap > OperatorFactory
 Operator factory definition. More...
 

Enumerations

enum  GeomData { eJac , eJacWithStdWeights , eDerivFactors }
 
enum  OperatorType {
  eBwdTrans , eHelmholtz , eIProductWRTBase , eIProductWRTDerivBase ,
  ePhysDeriv , SIZE_OperatorType
}
 
enum  ImplementationType {
  eNoImpType , eNoCollection , eIterPerExp , eStdMat ,
  eSumFac , eMatrixFree , SIZE_ImplementationType
}
 

Functions

void QuadIProduct (bool colldir0, bool colldir1, int numElmt, int nquad0, int nquad1, int nmodes0, int nmodes1, const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &jac, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp)
 
void TriIProduct (bool sortTopVertex, int numElmt, int nquad0, int nquad1, int nmodes0, int nmodes1, const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &jac, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp)
 
void HexIProduct (bool colldir0, bool colldir1, bool colldir2, int numElmt, int nquad0, int nquad1, int nquad2, int nmodes0, int nmodes1, int nmodes2, const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &jac, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp)
 
void PrismIProduct (bool sortTopVert, int numElmt, int nquad0, int nquad1, int nquad2, int nmodes0, int nmodes1, int nmodes2, const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &jac, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp)
 
void PyrIProduct (bool sortTopVert, int numElmt, int nquad0, int nquad1, int nquad2, int nmodes0, int nmodes1, int nmodes2, const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &jac, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp)
 
void TetIProduct (bool sortTopEdge, int numElmt, int nquad0, int nquad1, int nquad2, int nmodes0, int nmodes1, int nmodes2, const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &jac, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp)
 
bool operator< (OperatorKey const &p1, OperatorKey const &p2)
 Less-than comparison operator for OperatorKey objects. More...
 
std::ostream & operator<< (std::ostream &os, OperatorKey const &p)
 Stream output operator for OperatorKey objects. More...
 
OperatorFactory & GetOperatorFactory ()
 Returns the singleton Operator factory object. More...
 
OperatorImpMap SetFixedImpType (ImplementationType defaultType)
 simple Operator Implementation Map generator More...
 

Variables

static CoalescedGeomDataSharedPtr GeomDataNull
 
const char *const OperatorTypeMap []
 
const char *const OperatorTypeMap1 []
 
const char *const ImplementationTypeMap []
 
const char *const ImplementationTypeMap1 []
 

Typedef Documentation

◆ CoalescedGeomDataSharedPtr

typedef std::shared_ptr< CoalescedGeomData > Nektar::Collections::CoalescedGeomDataSharedPtr

Definition at line 92 of file CoalescedGeomData.h.

◆ CollectionVector

typedef std::vector<Collection> Nektar::Collections::CollectionVector

Definition at line 110 of file Collection.h.

◆ CollectionVectorSharedPtr

typedef std::shared_ptr<CollectionVector> Nektar::Collections::CollectionVectorSharedPtr

Definition at line 111 of file Collection.h.

◆ ExpansionIsNodal

typedef bool Nektar::Collections::ExpansionIsNodal

Definition at line 110 of file Operator.h.

◆ OperatorFactory

typedef Nektar::LibUtilities::NekFactory< OperatorKey, Operator, std::vector<StdRegions::StdExpansionSharedPtr>, CoalescedGeomDataSharedPtr, StdRegions::FactorMap> Nektar::Collections::OperatorFactory

Operator factory definition.

Definition at line 189 of file Operator.h.

◆ OperatorImpMap

typedef std::map<OperatorType, ImplementationType> Nektar::Collections::OperatorImpMap

Definition at line 112 of file Operator.h.

◆ OperatorKey

typedef std::tuple<LibUtilities::ShapeType, OperatorType, ImplementationType, ExpansionIsNodal> Nektar::Collections::OperatorKey

Key for describing an Operator.

Definition at line 177 of file Operator.h.

◆ OperatorSharedPtr

typedef std::shared_ptr<Operator> Nektar::Collections::OperatorSharedPtr

Shared pointer to an Operator object.

Definition at line 172 of file Operator.h.

◆ vec_t

using Nektar::Collections::vec_t = typedef simd<NekDouble>

Definition at line 49 of file CoalescedGeomData.h.

◆ VecVec_t

typedef std::vector<vec_t, tinysimd::allocator<vec_t> > Nektar::Collections::VecVec_t

Definition at line 50 of file CoalescedGeomData.h.

Enumeration Type Documentation

◆ GeomData

enum Nektar::Collections::GeomData
Enumerator
eJac 
eJacWithStdWeights 
eDerivFactors 

Definition at line 52 of file CoalescedGeomData.h.

53 {
54  eJac,
55  eJacWithStdWeights,
56  eDerivFactors
57 };

◆ ImplementationType

enum Nektar::Collections::ImplementationType
Enumerator
eNoImpType 
eNoCollection 
eIterPerExp 
eStdMat 
eSumFac 
eMatrixFree 
SIZE_ImplementationType 

Definition at line 83 of file Operator.h.

84 {
85  eNoImpType,
86  eNoCollection,
87  eIterPerExp,
88  eStdMat,
89  eSumFac,
90  eMatrixFree,
91  SIZE_ImplementationType
92 };

◆ OperatorType

enum Nektar::Collections::OperatorType
Enumerator
eBwdTrans 
eHelmholtz 
eIProductWRTBase 
eIProductWRTDerivBase 
ePhysDeriv 
SIZE_OperatorType 

Definition at line 66 of file Operator.h.

67 {
68  eBwdTrans,
69  eHelmholtz,
70  eIProductWRTBase,
71  eIProductWRTDerivBase,
72  ePhysDeriv,
73  SIZE_OperatorType
74 };

Function Documentation

◆ GetOperatorFactory()

OperatorFactory & Nektar::Collections::GetOperatorFactory ( )

Returns the singleton Operator factory object.

Definition at line 117 of file Operator.cpp.

118 {
119  static OperatorFactory instance;
120  return instance;
121 }
Nektar::Collections::OperatorFactory
Nektar::LibUtilities::NekFactory< OperatorKey, Operator, std::vector< StdRegions::StdExpansionSharedPtr >, CoalescedGeomDataSharedPtr, StdRegions::FactorMap > OperatorFactory
Operator factory definition.
Definition: Operator.h:189

Referenced by Nektar::Collections::BwdTrans_MatrixFree::BwdTrans_MatrixFree(), Nektar::Collections::Helmholtz_MatrixFree::Helmholtz_MatrixFree(), Nektar::Collections::Collection::Initialise(), Nektar::Collections::IProductWRTBase_MatrixFree::IProductWRTBase_MatrixFree(), Nektar::Collections::IProductWRTDerivBase_MatrixFree::IProductWRTDerivBase_MatrixFree(), Nektar::Collections::PhysDeriv_MatrixFree::PhysDeriv_MatrixFree(), and Nektar::Collections::CollectionOptimisation::SetWithTimings().

◆ HexIProduct()

void Nektar::Collections::HexIProduct ( bool  colldir0,
bool  colldir1,
bool  colldir2,
int  numElmt,
int  nquad0,
int  nquad1,
int  nquad2,
int  nmodes0,
int  nmodes1,
int  nmodes2,
const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  base2,
const Array< OneD, const NekDouble > &  jac,
const Array< OneD, const NekDouble > &  input,
Array< OneD, NekDouble > &  output,
Array< OneD, NekDouble > &  wsp 
)

Definition at line 173 of file IProduct.cpp.

181 {
182  int totmodes = nmodes0 * nmodes1 * nmodes2;
183  int totpoints = nquad0 * nquad1 * nquad2;
184 
185  if (colldir0 && colldir1 && colldir2)
186  {
187 
188  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, output, 1);
189  }
190  else
191  {
192  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
193 
194  // Assign second half of workspace for 2nd DGEMM operation.
195  Array<OneD, NekDouble> wsp1 = wsp + totpoints * numElmt;
196 
197  // note sure what criterion we should use to swap around these
198  // strategies
199  if (numElmt < nmodes0 || 1)
200  {
201  Array<OneD, NekDouble> wsp2 = wsp1 + nmodes0 * nquad1 * nquad2;
202 
203  // loop over elements
204  for (int n = 0; n < numElmt; ++n)
205  {
206  if (colldir0)
207  {
208 
209  for (int i = 0; i < nmodes0; ++i)
210  {
211  Vmath::Vcopy(nquad1 * nquad2, &wsp[n * totpoints] + i,
212  nquad0, wsp1.get() + nquad1 * nquad2 * i,
213  1);
214  }
215  }
216  else
217  {
218  Blas::Dgemm('T', 'N', nquad1 * nquad2, nmodes0, nquad0, 1.0,
219  &wsp[n * totpoints], nquad0, base0.get(),
220  nquad0, 0.0, wsp1.get(), nquad1 * nquad2);
221  }
222 
223  if (colldir1)
224  {
225  // reshuffle data for next operation.
226  for (int i = 0; i < nmodes1; ++i)
227  {
228  Vmath::Vcopy(nquad2 * nmodes0, wsp1.get() + i, nquad1,
229  wsp2.get() + nquad2 * nmodes0 * i, 1);
230  }
231  }
232  else
233  {
234  Blas::Dgemm('T', 'N', nquad2 * nmodes0, nmodes1, nquad1,
235  1.0, wsp1.get(), nquad1, base1.get(), nquad1,
236  0.0, wsp2.get(), nquad2 * nmodes0);
237  }
238 
239  if (colldir2)
240  {
241  // reshuffle data for next operation.
242  for (int i = 0; i < nmodes2; ++i)
243  {
244  Vmath::Vcopy(
245  nmodes0 * nmodes1, wsp2.get() + i, nquad2,
246  &output[n * totmodes] + nmodes0 * nmodes1 * i, 1);
247  }
248  }
249  else
250  {
251  Blas::Dgemm('T', 'N', nmodes0 * nmodes1, nmodes2, nquad2,
252  1.0, wsp2.get(), nquad2, base2.get(), nquad2,
253  0.0, &output[n * totmodes], nmodes0 * nmodes1);
254  }
255  }
256  }
257  else
258  {
259  Array<OneD, NekDouble> wsp2 =
260  wsp1 + numElmt * (max(totpoints, totmodes));
261 
262  if (colldir0)
263  {
264  for (int i = 0; i < nquad0; ++i)
265  {
266  Vmath::Vcopy(nquad1 * nquad2 * numElmt, &wsp[i], nquad0,
267  &wsp1[i * nquad1 * nquad2 * numElmt], 1);
268  }
269  }
270  else
271  {
272  // large degmm but copy at end.
273  Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0,
274  nquad0, 1.0, &wsp[0], nquad0, base0.get(), nquad0,
275  0.0, &wsp1[0], nquad1 * nquad2 * numElmt);
276  }
277 
278  if (colldir1)
279  {
280  for (int i = 0; i < nquad1; ++i)
281  {
282  Vmath::Vcopy(nquad2 * numElmt * nmodes0, &wsp1[i], nquad1,
283  &wsp2[i * nquad2 * numElmt * nmodes0], 1);
284  }
285  }
286  else
287  {
288  Blas::Dgemm('T', 'N', nquad2 * numElmt * nmodes0, nmodes1,
289  nquad1, 1.0, &wsp1[0], nquad1, base1.get(), nquad1,
290  0.0, &wsp2[0], nquad2 * numElmt * nmodes0);
291  }
292 
293  if (numElmt > 1)
294  {
295  if (colldir2)
296  {
297  for (int i = 0; i < nquad2; ++i)
298  {
299  Vmath::Vcopy(nmodes0 * nmodes1, &wsp2[i], nquad2,
300  &output[i * nmodes0 * nmodes1], 1);
301  }
302  }
303  else
304  {
305  Blas::Dgemm('T', 'N', numElmt * nmodes0 * nmodes1, nmodes2,
306  nquad2, 1.0, &wsp2[0], nquad2, base2.get(),
307  nquad2, 0.0, &wsp1[0],
308  numElmt * nmodes0 * nmodes1);
309  }
310 
311  for (int i = 0; i < totmodes; ++i)
312  {
313  Vmath::Vcopy(numElmt, &wsp1[i * numElmt], 1, &output[i],
314  totmodes);
315  }
316  }
317  else
318  {
319  if (colldir2)
320  {
321  for (int i = 0; i < nquad2; ++i)
322  {
323  Vmath::Vcopy(nmodes0 * nmodes1, &wsp2[i], nquad2,
324  &output[i * nmodes0 * nmodes1], 1);
325  }
326  }
327  else
328  {
329  Blas::Dgemm('T', 'N', numElmt * nmodes0 * nmodes1, nmodes2,
330  nquad2, 1.0, &wsp2[0], nquad2, base2.get(),
331  nquad2, 0.0, &output[0],
332  numElmt * nmodes0 * nmodes1);
333  }
334  }
335  }
336  }
337 }
Blas::Dgemm
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where op(A)[m x k], op(B)[k x n], C[m x n] DGEMM perfo...
Definition: Blas.hpp:368
Vmath::Vmul
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:209
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255

References Blas::Dgemm(), Vmath::Vcopy(), and Vmath::Vmul().

Referenced by Nektar::Collections::IProductWRTDerivBase_SumFac_Hex::operator()(), and Nektar::Collections::IProductWRTBase_SumFac_Hex::operator()().

◆ operator<()

bool Nektar::Collections::operator< ( OperatorKey const &  p1,
OperatorKey const &  p2 
)

Less-than comparison operator for OperatorKey objects.

Definition at line 56 of file Operator.cpp.

57 {
58  if (std::get<0>(p1) < std::get<0>(p2))
59  {
60  return true;
61  }
62  if (std::get<0>(p1) > std::get<0>(p2))
63  {
64  return false;
65  }
66  if (std::get<1>(p1) < std::get<1>(p2))
67  {
68  return true;
69  }
70  if (std::get<1>(p1) > std::get<1>(p2))
71  {
72  return false;
73  }
74  if (std::get<2>(p1) < std::get<2>(p2))
75  {
76  return true;
77  }
78  if (std::get<2>(p1) > std::get<2>(p2))
79  {
80  return false;
81  }
82 
83  if (std::get<3>(p1) < std::get<3>(p2))
84  {
85  return true;
86  }
87  if (std::get<3>(p1) > std::get<3>(p2))
88  {
89  return false;
90  }
91 
92  return false;
93 }

◆ operator<<()

std::ostream & Nektar::Collections::operator<< ( std::ostream &  os,
OperatorKey const &  p 
)

Stream output operator for OperatorKey objects.

Definition at line 98 of file Operator.cpp.

99 {
100  os << LibUtilities::ShapeTypeMap[std::get<0>(p)] << ", "
101  << OperatorTypeMap[std::get<1>(p)] << ", "
102  << ImplementationTypeMap[std::get<2>(p)] << ", "
103  << (std::get<3>(p) ? "Nodal" : "Modal");
104  return os;
105 }
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::Collections::ImplementationTypeMap
const char *const ImplementationTypeMap[]
Definition: Operator.h:94
Nektar::Collections::OperatorTypeMap
const char *const OperatorTypeMap[]
Definition: Operator.h:76

References ImplementationTypeMap, OperatorTypeMap, and CellMLToNektar.cellml_metadata::p.

◆ PrismIProduct()

void Nektar::Collections::PrismIProduct ( bool  sortTopVert,
int  numElmt,
int  nquad0,
int  nquad1,
int  nquad2,
int  nmodes0,
int  nmodes1,
int  nmodes2,
const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  base2,
const Array< OneD, const NekDouble > &  jac,
const Array< OneD, const NekDouble > &  input,
Array< OneD, NekDouble > &  output,
Array< OneD, NekDouble > &  wsp 
)

Definition at line 342 of file IProduct.cpp.

350 {
351  int totmodes = LibUtilities::StdPrismData::getNumberOfCoefficients(
352  nmodes0, nmodes1, nmodes2);
353  int totpoints = nquad0 * nquad1 * nquad2;
354  int cnt;
355  int mode, mode1;
356 
357  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
358 
359  Array<OneD, NekDouble> wsp1 =
360  wsp + numElmt * nquad2 * (max(nquad0 * nquad1, nmodes0 * nmodes1));
361 
362  // Perform iproduct with respect to the '0' direction
363  Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
364  wsp.get(), nquad0, base0.get(), nquad0, 0.0, wsp1.get(),
365  nquad1 * nquad2 * numElmt);
366 
367  // Perform iproduct with respect to the '1' direction
368  Blas::Dgemm('T', 'N', nquad2 * numElmt * nmodes0, nmodes1, nquad1, 1.0,
369  wsp1.get(), nquad1, base1.get(), nquad1, 0.0, wsp.get(),
370  nquad2 * numElmt * nmodes0);
371 
372  // Inner product with respect to the '2' direction (not sure if it would
373  // be better to swap loops?)
374  mode = mode1 = cnt = 0;
375  for (int i = 0; i < nmodes0; ++i)
376  {
377  cnt = i * nquad2 * numElmt;
378  for (int j = 0; j < nmodes1; ++j)
379  {
380  Blas::Dgemm('T', 'N', nmodes2 - i, numElmt, nquad2, 1.0,
381  base2.get() + mode * nquad2, nquad2,
382  wsp.get() + j * nquad2 * numElmt * nmodes0 + cnt,
383  nquad2, 0.0, output.get() + mode1, totmodes);
384  mode1 += nmodes2 - i;
385  }
386  mode += nmodes2 - i;
387  }
388 
389  // fix for modified basis by splitting top vertex mode
390  if (sortTopVertex)
391  {
392  // top singular vertex
393  // ((1+a)/2 components entry into (1+c)/2)
394  // Could be made into an mxv if we have specialised base1[1]
395  for (int j = 0; j < nmodes1; ++j)
396  {
397  Blas::Dgemv('T', nquad2, numElmt, 1.0,
398  wsp.get() + j * nquad2 * numElmt * nmodes0 +
399  nquad2 * numElmt,
400  nquad2, base2.get() + nquad2, 1, 1.0,
401  &output[j * nmodes2 + 1], totmodes);
402  }
403  }
404 }
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:246

References Blas::Dgemm(), Blas::Dgemv(), Nektar::LibUtilities::StdSegData::getNumberOfCoefficients(), and Vmath::Vmul().

Referenced by Nektar::Collections::IProductWRTDerivBase_SumFac_Prism::operator()(), and Nektar::Collections::IProductWRTBase_SumFac_Prism::operator()().

◆ PyrIProduct()

void Nektar::Collections::PyrIProduct ( bool  sortTopVert,
int  numElmt,
int  nquad0,
int  nquad1,
int  nquad2,
int  nmodes0,
int  nmodes1,
int  nmodes2,
const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  base2,
const Array< OneD, const NekDouble > &  jac,
const Array< OneD, const NekDouble > &  input,
Array< OneD, NekDouble > &  output,
Array< OneD, NekDouble > &  wsp 
)

Definition at line 409 of file IProduct.cpp.

417 {
418  int totmodes = LibUtilities::StdPyrData::getNumberOfCoefficients(
419  nmodes0, nmodes1, nmodes2);
420  int totpoints = nquad0 * nquad1 * nquad2;
421  int cnt;
422  int mode, mode1;
423 
424  ASSERTL1(wsp.size() >=
425  numElmt * (nquad1 * nquad2 * nmodes0 +
426  nquad2 * max(nquad0 * nquad1, nmodes0 * nmodes1)),
427  "Insufficient workspace size");
428 
429  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
430 
431  Array<OneD, NekDouble> wsp1 =
432  wsp + numElmt * nquad2 * (max(nquad0 * nquad1, nmodes0 * nmodes1));
433 
434  // Perform iproduct with respect to the '0' direction
435  Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
436  wsp.get(), nquad0, base0.get(), nquad0, 0.0, wsp1.get(),
437  nquad1 * nquad2 * numElmt);
438 
439  // Inner product with respect to the '1' direction
440  mode = 0;
441  for (int i = 0; i < nmodes0; ++i)
442  {
443  Blas::Dgemm('T', 'N', nquad2 * numElmt, nmodes1, nquad1, 1.0,
444  wsp1.get() + i * nquad1 * nquad2 * numElmt, nquad1,
445  base1.get(), nquad1, 0.0,
446  wsp.get() + mode * nquad2 * numElmt, nquad2 * numElmt);
447  mode += nmodes1;
448  }
449 
450  // Inner product with respect to the '2' direction
451  mode = mode1 = cnt = 0;
452  for (int i = 0; i < nmodes0; ++i)
453  {
454  for (int j = 0; j < nmodes1; ++j, ++cnt)
455  {
456  int ijmax = max(i, j);
457  Blas::Dgemm('T', 'N', nmodes2 - ijmax, numElmt, nquad2, 1.0,
458  base2.get() + mode * nquad2, nquad2,
459  wsp.get() + cnt * nquad2 * numElmt, nquad2, 0.0,
460  output.get() + mode1, totmodes);
461  mode += nmodes2 - ijmax;
462  mode1 += nmodes2 - ijmax;
463  }
464 
465  // increment mode in case order1!=order2
466  for (int j = nmodes1; j < nmodes2; ++j)
467  {
468  int ijmax = max(i, j);
469  mode += nmodes2 - ijmax;
470  }
471  }
472 
473  // fix for modified basis for top singular vertex component
474  // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
475  if (sortTopVertex)
476  {
477  for (int n = 0; n < numElmt; ++n)
478  {
479  // add in (1+c)/2 (1+b)/2 component
480  output[1 + n * totmodes] +=
481  Blas::Ddot(nquad2, base2.get() + nquad2, 1,
482  &wsp[nquad2 * numElmt + n * nquad2], 1);
483 
484  // add in (1+c)/2 (1-b)/2 (1+a)/2 component
485  output[1 + n * totmodes] +=
486  Blas::Ddot(nquad2, base2.get() + nquad2, 1,
487  &wsp[nquad2 * nmodes1 * numElmt + n * nquad2], 1);
488 
489  // add in (1+c)/2 (1+b)/2 (1+a)/2 component
490  output[1 + n * totmodes] += Blas::Ddot(
491  nquad2, base2.get() + nquad2, 1,
492  &wsp[nquad2 * (nmodes1 + 1) * numElmt + n * nquad2], 1);
493  }
494  }
495 }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
Blas::Ddot
static double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
Definition: Blas.hpp:182

References ASSERTL1, Blas::Ddot(), Blas::Dgemm(), Nektar::LibUtilities::StdSegData::getNumberOfCoefficients(), and Vmath::Vmul().

Referenced by Nektar::Collections::IProductWRTDerivBase_SumFac_Pyr::operator()(), and Nektar::Collections::IProductWRTBase_SumFac_Pyr::operator()().

◆ QuadIProduct()

void Nektar::Collections::QuadIProduct ( bool  colldir0,
bool  colldir1,
int  numElmt,
int  nquad0,
int  nquad1,
int  nmodes0,
int  nmodes1,
const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  jac,
const Array< OneD, const NekDouble > &  input,
Array< OneD, NekDouble > &  output,
Array< OneD, NekDouble > &  wsp 
)

Definition at line 48 of file IProduct.cpp.

55 {
56  int totpoints = nquad0 * nquad1;
57  int totmodes = nmodes0 * nmodes1;
58 
59  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
60 
61  if (colldir0 && colldir1)
62  {
63  Vmath::Vcopy(numElmt * totmodes, wsp.get(), 1, output.get(), 1);
64  }
65  else
66  {
67  Array<OneD, NekDouble> wsp1 = wsp + max(totpoints, totmodes) * numElmt;
68  if (colldir0)
69  {
70  for (int i = 0; i < nquad0; ++i)
71  {
72  Vmath::Vcopy(nquad1 * numElmt, &wsp[i], nquad0,
73  &wsp1[i * nquad1 * numElmt], 1);
74  }
75  }
76  else
77  {
78  Blas::Dgemm('T', 'N', nquad1 * numElmt, nmodes0, nquad0, 1.0,
79  &wsp[0], nquad0, base0.get(), nquad0, 0.0, &wsp1[0],
80  nquad1 * numElmt);
81  }
82 
83  if (numElmt > 1)
84  {
85 
86  if (colldir1)
87  {
88  for (int i = 0; i < nquad1; ++i)
89  {
90  Vmath::Vcopy(numElmt * nmodes0, &wsp1[i], nquad1,
91  &wsp[i * numElmt * nmodes0], 1);
92  }
93  }
94  else
95  {
96 
97  Blas::Dgemm('T', 'N', numElmt * nmodes0, nmodes1, nquad1, 1.0,
98  &wsp1[0], nquad1, base1.get(), nquad1, 0.0, &wsp[0],
99  numElmt * nmodes0);
100  }
101 
102  for (int i = 0; i < totmodes; ++i)
103  {
104  Vmath::Vcopy(numElmt, &wsp[i * numElmt], 1, &output[i],
105  totmodes);
106  }
107  }
108  else
109  {
110  if (colldir1)
111  {
112  for (int i = 0; i < nquad1; ++i)
113  {
114  Vmath::Vcopy(numElmt * nmodes0, &wsp1[i], nquad1,
115  &output[i * numElmt * nmodes0], 1);
116  }
117  }
118  else
119  {
120  Blas::Dgemm('T', 'N', nmodes0, nmodes1, nquad1, 1.0, &wsp1[0],
121  nquad1, base1.get(), nquad1, 0.0, &output[0],
122  nmodes0);
123  }
124  }
125  }
126 }

References Blas::Dgemm(), Vmath::Vcopy(), and Vmath::Vmul().

Referenced by Nektar::Collections::IProductWRTDerivBase_SumFac_Quad::operator()(), and Nektar::Collections::IProductWRTBase_SumFac_Quad::operator()().

◆ SetFixedImpType()

OperatorImpMap Nektar::Collections::SetFixedImpType ( ImplementationType  defaultType)

simple Operator Implementation Map generator

Definition at line 124 of file Operator.cpp.

125 {
126  OperatorImpMap opMap;
127 
128  for (int i = 0; i < SIZE_OperatorType; ++i)
129  {
130  opMap[(OperatorType)i] = defaultType;
131  }
132 
133  return opMap;
134 }
Nektar::Collections::OperatorImpMap
std::map< OperatorType, ImplementationType > OperatorImpMap
Definition: Operator.h:112

References SIZE_OperatorType.

◆ TetIProduct()

void Nektar::Collections::TetIProduct ( bool  sortTopEdge,
int  numElmt,
int  nquad0,
int  nquad1,
int  nquad2,
int  nmodes0,
int  nmodes1,
int  nmodes2,
const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  base2,
const Array< OneD, const NekDouble > &  jac,
const Array< OneD, const NekDouble > &  input,
Array< OneD, NekDouble > &  output,
Array< OneD, NekDouble > &  wsp 
)

Definition at line 500 of file IProduct.cpp.

508 {
509  int totmodes = LibUtilities::StdTetData::getNumberOfCoefficients(
510  nmodes0, nmodes1, nmodes2);
511  int totpoints = nquad0 * nquad1 * nquad2;
512  int cnt;
513  int mode, mode1;
514 
515  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
516 
517  Array<OneD, NekDouble> wsp1 =
518  wsp +
519  nquad2 * numElmt *
520  (max(nquad0 * nquad1, nmodes0 * (2 * nmodes1 - nmodes0 + 1) / 2));
521 
522  // Perform iproduct with respect to the '0' direction
523  Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
524  wsp.get(), nquad0, base0.get(), nquad0, 0.0, wsp1.get(),
525  nquad1 * nquad2 * numElmt);
526 
527  // Inner product with respect to the '1' direction
528  mode = 0;
529  for (int i = 0; i < nmodes0; ++i)
530  {
531  Blas::Dgemm('T', 'N', nquad2 * numElmt, nmodes1 - i, nquad1, 1.0,
532  wsp1.get() + i * nquad1 * nquad2 * numElmt, nquad1,
533  base1.get() + mode * nquad1, nquad1, 0.0,
534  wsp.get() + mode * nquad2 * numElmt, nquad2 * numElmt);
535  mode += nmodes1 - i;
536  }
537 
538  // fix for modified basis by splitting top vertex mode
539  if (sortTopEdge)
540  {
541  // base singular vertex and singular edge (1+b)/2
542  // ((1+a)/2 components entry into (1+b)/2)
543  // Could be made into an mxm if we have specialised base1[1]
544  for (int n = 0; n < numElmt; ++n)
545  {
546  Blas::Dgemv('T', nquad1, nquad2, 1.0,
547  wsp1.get() + numElmt * nquad1 * nquad2 +
548  n * nquad1 * nquad2,
549  nquad1, base1.get() + nquad1, 1, 1.0,
550  wsp.get() + nquad2 * numElmt + n * nquad2, 1);
551  }
552  }
553 
554  // Inner product with respect to the '2' direction
555  mode = mode1 = cnt = 0;
556  for (int i = 0; i < nmodes0; ++i)
557  {
558  for (int j = 0; j < nmodes1 - i; ++j, ++cnt)
559  {
560  Blas::Dgemm('T', 'N', nmodes2 - i - j, numElmt, nquad2, 1.0,
561  base2.get() + mode * nquad2, nquad2,
562  wsp.get() + cnt * nquad2 * numElmt, nquad2, 0.0,
563  output.get() + mode1, totmodes);
564  mode += nmodes2 - i - j;
565  mode1 += nmodes2 - i - j;
566  }
567 
568  // increment mode in case order1!=order2
569  mode += (nmodes2 - nmodes1) * (nmodes2 - nmodes1 + 1) / 2;
570  }
571 
572  // fix for modified basis for top singular vertex component
573  // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
574  if (sortTopEdge)
575  {
576  for (int n = 0; n < numElmt; ++n)
577  {
578  // add in (1+c)/2 (1+b)/2 component
579  output[1 + n * totmodes] +=
580  Blas::Ddot(nquad2, base2.get() + nquad2, 1,
581  &wsp[nquad2 * numElmt + n * nquad2], 1);
582 
583  // add in (1+c)/2 (1-b)/2 (1+a)/2 component
584  output[1 + n * totmodes] +=
585  Blas::Ddot(nquad2, base2.get() + nquad2, 1,
586  &wsp[nquad2 * nmodes1 * numElmt + n * nquad2], 1);
587  }
588  }
589 }

References Blas::Ddot(), Blas::Dgemm(), Blas::Dgemv(), Nektar::LibUtilities::StdSegData::getNumberOfCoefficients(), and Vmath::Vmul().

Referenced by Nektar::Collections::IProductWRTDerivBase_SumFac_Tet::operator()(), and Nektar::Collections::IProductWRTBase_SumFac_Tet::operator()().

◆ TriIProduct()

void Nektar::Collections::TriIProduct ( bool  sortTopVertex,
int  numElmt,
int  nquad0,
int  nquad1,
int  nmodes0,
int  nmodes1,
const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  jac,
const Array< OneD, const NekDouble > &  input,
Array< OneD, NekDouble > &  output,
Array< OneD, NekDouble > &  wsp 
)

Definition at line 131 of file IProduct.cpp.

138 {
139  int totmodes =
140  LibUtilities::StdTriData::getNumberOfCoefficients(nmodes0, nmodes1);
141  int totpoints = nquad0 * nquad1;
142 
143  Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
144 
145  Array<OneD, NekDouble> wsp1 = wsp + max(totpoints, totmodes) * numElmt;
146 
147  Blas::Dgemm('T', 'N', nquad1 * numElmt, nmodes0, nquad0, 1.0, &wsp[0],
148  nquad0, base0.get(), nquad0, 0.0, &wsp1[0], nquad1 * numElmt);
149 
150  int i, mode;
151  // Inner product with respect to 'b' direction
152  for (mode = i = 0; i < nmodes0; ++i)
153  {
154  Blas::Dgemm('T', 'N', nmodes1 - i, numElmt, nquad1, 1.0,
155  base1.get() + mode * nquad1, nquad1,
156  wsp1.get() + i * nquad1 * numElmt, nquad1, 0.0,
157  &output[mode], totmodes);
158 
159  mode += nmodes1 - i;
160  }
161 
162  // fix for modified basis by splitting top vertex mode
163  if (sortTopVertex)
164  {
165  Blas::Dgemv('T', nquad1, numElmt, 1.0, wsp1.get() + nquad1 * numElmt,
166  nquad1, base1.get() + nquad1, 1, 1.0, &output[1], totmodes);
167  }
168 }

References Blas::Dgemm(), Blas::Dgemv(), Nektar::LibUtilities::StdSegData::getNumberOfCoefficients(), and Vmath::Vmul().

Referenced by Nektar::Collections::IProductWRTDerivBase_SumFac_Tri::operator()(), and Nektar::Collections::IProductWRTBase_SumFac_Tri::operator()().

Variable Documentation

◆ GeomDataNull

CoalescedGeomDataSharedPtr Nektar::Collections::GeomDataNull
static

Definition at line 94 of file CoalescedGeomData.h.

◆ ImplementationTypeMap

const char* const Nektar::Collections::ImplementationTypeMap[]
Initial value:
= {"NoImplementationType",
"NoCollection",
"IterPerExp",
"StdMat",
"SumFac",
"MatrixFree"}

Definition at line 94 of file Operator.h.

Referenced by Nektar::Collections::CollectionOptimisation::CollectionOptimisation(), operator<<(), Nektar::Collections::CollectionOptimisation::ReadCollOps(), and Nektar::Collections::CollectionOptimisation::UpdateOptFile().

◆ ImplementationTypeMap1

const char* const Nektar::Collections::ImplementationTypeMap1[]
Initial value:
= {
"NoImplementationType",
"IterLocExp",
"IterStdExp",
"StdMat ",
"SumFac ",
"MatFree "
}

Definition at line 101 of file Operator.h.

Referenced by Nektar::Collections::CollectionOptimisation::SetWithTimings().

◆ OperatorTypeMap

const char* const Nektar::Collections::OperatorTypeMap[]
Initial value:
= {"BwdTrans", "Helmholtz",
"IProductWRTBase",
"IProductWRTDerivBase", "PhysDeriv"}

Definition at line 76 of file Operator.h.

Referenced by Nektar::Collections::CollectionOptimisation::CollectionOptimisation(), Nektar::Collections::Collection::Initialise(), operator<<(), Nektar::Collections::CollectionOptimisation::ReadCollOps(), and Nektar::Collections::CollectionOptimisation::UpdateOptFile().

◆ OperatorTypeMap1

const char* const Nektar::Collections::OperatorTypeMap1[]
Initial value:
= {"BwdTrans", "Helmholtz", "IPWrtBase",
"IPWrtDBase", "PhysDeriv "}

Definition at line 80 of file Operator.h.

Referenced by Nektar::Collections::CollectionOptimisation::SetWithTimings().

Generated on Sat Mar 25 2023 12:35:56 for Nektar++ by doxygen 1.9.1