Nektar++
IProduct.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: IProduct.cpp
4//
5// For more information, please see: http://www.nektar.info
6//
7// The MIT License
8//
9// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10// Department of Aeronautics, Imperial College London (UK), and Scientific
11// Computing and Imaging Institute, University of Utah (USA).
12//
13// Permission is hereby granted, free of charge, to any person obtaining a
14// copy of this software and associated documentation files (the "Software"),
15// to deal in the Software without restriction, including without limitation
16// the rights to use, copy, modify, merge, publish, distribute, sublicense,
17
18// Software is furnished to do so, subject to the following conditions:
19//
20// The above copyright notice and this permission notice shall be included
21// in all copies or substantial portions of the Software.
22//
23// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29// DEALINGS IN THE SOFTWARE.
30//
31// Description: IProduct operators for multiple calls in different operators
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#include <Collections/Collection.h>
36#include <Collections/IProduct.h>
37
38using namespace std;
39
40namespace Nektar::Collections
41{
42
43/**
44 *
45 */
46void QuadIProduct(bool colldir0, bool colldir1, int numElmt, int nquad0,
47 int nquad1, int nmodes0, int nmodes1,
48 const Array<OneD, const NekDouble> &base0,
49 const Array<OneD, const NekDouble> &base1,
50 const Array<OneD, const NekDouble> &jac,
51 const Array<OneD, const NekDouble> &input,
52 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
53{
54 int totpoints = nquad0 * nquad1;
55 int totmodes = nmodes0 * nmodes1;
56
57 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
58
59 if (colldir0 && colldir1)
60 {
61 Vmath::Vcopy(numElmt * totmodes, wsp.get(), 1, output.get(), 1);
62 }
63 else
64 {
65 Array<OneD, NekDouble> wsp1 = wsp + max(totpoints, totmodes) * numElmt;
66 if (colldir0)
67 {
68 for (int i = 0; i < nquad0; ++i)
69 {
70 Vmath::Vcopy(nquad1 * numElmt, &wsp[i], nquad0,
71 &wsp1[i * nquad1 * numElmt], 1);
72 }
73 }
74 else
75 {
76 Blas::Dgemm('T', 'N', nquad1 * numElmt, nmodes0, nquad0, 1.0,
77 &wsp[0], nquad0, base0.get(), nquad0, 0.0, &wsp1[0],
78 nquad1 * numElmt);
79 }
80
81 if (numElmt > 1)
82 {
83 if (colldir1)
84 {
85 for (int i = 0; i < nquad1; ++i)
86 {
87 Vmath::Vcopy(numElmt * nmodes0, &wsp1[i], nquad1,
88 &wsp[i * numElmt * nmodes0], 1);
89 }
90 }
91 else
92 {
93
94 Blas::Dgemm('T', 'N', numElmt * nmodes0, nmodes1, nquad1, 1.0,
95 &wsp1[0], nquad1, base1.get(), nquad1, 0.0, &wsp[0],
96 numElmt * nmodes0);
97 }
98
99 for (int i = 0; i < totmodes; ++i)
100 {
101 Vmath::Vcopy(numElmt, &wsp[i * numElmt], 1, &output[i],
102 totmodes);
103 }
104 }
105 else
106 {
107 if (colldir1)
108 {
109 for (int i = 0; i < nquad1; ++i)
110 {
111 Vmath::Vcopy(numElmt * nmodes0, &wsp1[i], nquad1,
112 &output[i * numElmt * nmodes0], 1);
113 }
114 }
115 else
116 {
117 Blas::Dgemm('T', 'N', nmodes0, nmodes1, nquad1, 1.0, &wsp1[0],
118 nquad1, base1.get(), nquad1, 0.0, &output[0],
119 nmodes0);
120 }
121 }
122 }
123}
124
125/**
126 *
127 */
128void TriIProduct(bool sortTopVertex, int numElmt, int nquad0, int nquad1,
129 int nmodes0, int nmodes1,
130 const Array<OneD, const NekDouble> &base0,
131 const Array<OneD, const NekDouble> &base1,
132 const Array<OneD, const NekDouble> &jac,
133 const Array<OneD, const NekDouble> &input,
134 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
135{
136 int totmodes =
137 LibUtilities::StdTriData::getNumberOfCoefficients(nmodes0, nmodes1);
138 int totpoints = nquad0 * nquad1;
139
140 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
141
142 Array<OneD, NekDouble> wsp1 = wsp + max(totpoints, totmodes) * numElmt;
143
144 Blas::Dgemm('T', 'N', nquad1 * numElmt, nmodes0, nquad0, 1.0, &wsp[0],
145 nquad0, base0.get(), nquad0, 0.0, &wsp1[0], nquad1 * numElmt);
146
147 int i, mode;
148 // Inner product with respect to 'b' direction
149 for (mode = i = 0; i < nmodes0; ++i)
150 {
151 Blas::Dgemm('T', 'N', nmodes1 - i, numElmt, nquad1, 1.0,
152 base1.get() + mode * nquad1, nquad1,
153 wsp1.get() + i * nquad1 * numElmt, nquad1, 0.0,
154 &output[mode], totmodes);
155
156 mode += nmodes1 - i;
157 }
158
159 // fix for modified basis by splitting top vertex mode
160 if (sortTopVertex)
161 {
162 Blas::Dgemv('T', nquad1, numElmt, 1.0, wsp1.get() + nquad1 * numElmt,
163 nquad1, base1.get() + nquad1, 1, 1.0, &output[1], totmodes);
164 }
165}
166
167/**
168 *
169 */
170void HexIProduct(bool colldir0, bool colldir1, bool colldir2, int numElmt,
171 int nquad0, int nquad1, int nquad2, int nmodes0, int nmodes1,
172 int nmodes2, const Array<OneD, const NekDouble> &base0,
173 const Array<OneD, const NekDouble> &base1,
174 const Array<OneD, const NekDouble> &base2,
175 const Array<OneD, const NekDouble> &jac,
176 const Array<OneD, const NekDouble> &input,
177 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
178{
179 int totmodes = nmodes0 * nmodes1 * nmodes2;
180 int totpoints = nquad0 * nquad1 * nquad2;
181
182 if (colldir0 && colldir1 && colldir2)
183 {
184
185 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, output, 1);
186 }
187 else
188 {
189 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
190
191 // Assign second half of workspace for 2nd DGEMM operation.
192 Array<OneD, NekDouble> wsp1 = wsp + totpoints * numElmt;
193
194 // note sure what criterion we should use to swap around these
195 // strategies
196 if (numElmt < nmodes0 || 1)
197 {
198 Array<OneD, NekDouble> wsp2 = wsp1 + nmodes0 * nquad1 * nquad2;
199
200 // loop over elements
201 for (int n = 0; n < numElmt; ++n)
202 {
203 if (colldir0)
204 {
205 for (int i = 0; i < nmodes0; ++i)
206 {
207 Vmath::Vcopy(nquad1 * nquad2, &wsp[n * totpoints] + i,
208 nquad0, wsp1.get() + nquad1 * nquad2 * i,
209 1);
210 }
211 }
212 else
213 {
214 Blas::Dgemm('T', 'N', nquad1 * nquad2, nmodes0, nquad0, 1.0,
215 &wsp[n * totpoints], nquad0, base0.get(),
216 nquad0, 0.0, wsp1.get(), nquad1 * nquad2);
217 }
218
219 if (colldir1)
220 {
221 // reshuffle data for next operation.
222 for (int i = 0; i < nmodes1; ++i)
223 {
224 Vmath::Vcopy(nquad2 * nmodes0, wsp1.get() + i, nquad1,
225 wsp2.get() + nquad2 * nmodes0 * i, 1);
226 }
227 }
228 else
229 {
230 Blas::Dgemm('T', 'N', nquad2 * nmodes0, nmodes1, nquad1,
231 1.0, wsp1.get(), nquad1, base1.get(), nquad1,
232 0.0, wsp2.get(), nquad2 * nmodes0);
233 }
234
235 if (colldir2)
236 {
237 // reshuffle data for next operation.
238 for (int i = 0; i < nmodes2; ++i)
239 {
240 Vmath::Vcopy(
241 nmodes0 * nmodes1, wsp2.get() + i, nquad2,
242 &output[n * totmodes] + nmodes0 * nmodes1 * i, 1);
243 }
244 }
245 else
246 {
247 Blas::Dgemm('T', 'N', nmodes0 * nmodes1, nmodes2, nquad2,
248 1.0, wsp2.get(), nquad2, base2.get(), nquad2,
249 0.0, &output[n * totmodes], nmodes0 * nmodes1);
250 }
251 }
252 }
253 else
254 {
255 Array<OneD, NekDouble> wsp2 =
256 wsp1 + numElmt * (max(totpoints, totmodes));
257
258 if (colldir0)
259 {
260 for (int i = 0; i < nquad0; ++i)
261 {
262 Vmath::Vcopy(nquad1 * nquad2 * numElmt, &wsp[i], nquad0,
263 &wsp1[i * nquad1 * nquad2 * numElmt], 1);
264 }
265 }
266 else
267 {
268 // large degmm but copy at end.
269 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0,
270 nquad0, 1.0, &wsp[0], nquad0, base0.get(), nquad0,
271 0.0, &wsp1[0], nquad1 * nquad2 * numElmt);
272 }
273
274 if (colldir1)
275 {
276 for (int i = 0; i < nquad1; ++i)
277 {
278 Vmath::Vcopy(nquad2 * numElmt * nmodes0, &wsp1[i], nquad1,
279 &wsp2[i * nquad2 * numElmt * nmodes0], 1);
280 }
281 }
282 else
283 {
284 Blas::Dgemm('T', 'N', nquad2 * numElmt * nmodes0, nmodes1,
285 nquad1, 1.0, &wsp1[0], nquad1, base1.get(), nquad1,
286 0.0, &wsp2[0], nquad2 * numElmt * nmodes0);
287 }
288
289 if (numElmt > 1)
290 {
291 if (colldir2)
292 {
293 for (int i = 0; i < nquad2; ++i)
294 {
295 Vmath::Vcopy(nmodes0 * nmodes1, &wsp2[i], nquad2,
296 &output[i * nmodes0 * nmodes1], 1);
297 }
298 }
299 else
300 {
301 Blas::Dgemm('T', 'N', numElmt * nmodes0 * nmodes1, nmodes2,
302 nquad2, 1.0, &wsp2[0], nquad2, base2.get(),
303 nquad2, 0.0, &wsp1[0],
304 numElmt * nmodes0 * nmodes1);
305 }
306
307 for (int i = 0; i < totmodes; ++i)
308 {
309 Vmath::Vcopy(numElmt, &wsp1[i * numElmt], 1, &output[i],
310 totmodes);
311 }
312 }
313 else
314 {
315 if (colldir2)
316 {
317 for (int i = 0; i < nquad2; ++i)
318 {
319 Vmath::Vcopy(nmodes0 * nmodes1, &wsp2[i], nquad2,
320 &output[i * nmodes0 * nmodes1], 1);
321 }
322 }
323 else
324 {
325 Blas::Dgemm('T', 'N', numElmt * nmodes0 * nmodes1, nmodes2,
326 nquad2, 1.0, &wsp2[0], nquad2, base2.get(),
327 nquad2, 0.0, &output[0],
328 numElmt * nmodes0 * nmodes1);
329 }
330 }
331 }
332 }
333}
334
335/**
336 *
337 */
338void PrismIProduct(bool sortTopVertex, int numElmt, int nquad0, int nquad1,
339 int nquad2, int nmodes0, int nmodes1, int nmodes2,
340 const Array<OneD, const NekDouble> &base0,
341 const Array<OneD, const NekDouble> &base1,
342 const Array<OneD, const NekDouble> &base2,
343 const Array<OneD, const NekDouble> &jac,
344 const Array<OneD, const NekDouble> &input,
345 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
346{
347 int totmodes = LibUtilities::StdPrismData::getNumberOfCoefficients(
348 nmodes0, nmodes1, nmodes2);
349 int totpoints = nquad0 * nquad1 * nquad2;
350 int cnt;
351 int mode, mode1;
352
353 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
354
355 Array<OneD, NekDouble> wsp1 =
356 wsp + numElmt * nquad2 * (max(nquad0 * nquad1, nmodes0 * nmodes1));
357
358 // Perform iproduct with respect to the '0' direction
359 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
360 wsp.get(), nquad0, base0.get(), nquad0, 0.0, wsp1.get(),
361 nquad1 * nquad2 * numElmt);
362
363 // Perform iproduct with respect to the '1' direction
364 Blas::Dgemm('T', 'N', nquad2 * numElmt * nmodes0, nmodes1, nquad1, 1.0,
365 wsp1.get(), nquad1, base1.get(), nquad1, 0.0, wsp.get(),
366 nquad2 * numElmt * nmodes0);
367
368 // Inner product with respect to the '2' direction (not sure if it would
369 // be better to swap loops?)
370 mode = mode1 = cnt = 0;
371 for (int i = 0; i < nmodes0; ++i)
372 {
373 cnt = i * nquad2 * numElmt;
374 for (int j = 0; j < nmodes1; ++j)
375 {
376 Blas::Dgemm('T', 'N', nmodes2 - i, numElmt, nquad2, 1.0,
377 base2.get() + mode * nquad2, nquad2,
378 wsp.get() + j * nquad2 * numElmt * nmodes0 + cnt,
379 nquad2, 0.0, output.get() + mode1, totmodes);
380 mode1 += nmodes2 - i;
381 }
382 mode += nmodes2 - i;
383 }
384
385 // fix for modified basis by splitting top vertex mode
386 if (sortTopVertex)
387 {
388 // top singular vertex
389 // ((1+a)/2 components entry into (1+c)/2)
390 // Could be made into an mxv if we have specialised base1[1]
391 for (int j = 0; j < nmodes1; ++j)
392 {
393 Blas::Dgemv('T', nquad2, numElmt, 1.0,
394 wsp.get() + j * nquad2 * numElmt * nmodes0 +
395 nquad2 * numElmt,
396 nquad2, base2.get() + nquad2, 1, 1.0,
397 &output[j * nmodes2 + 1], totmodes);
398 }
399 }
400}
401
402/**
403 *
404 */
405void PyrIProduct(bool sortTopVertex, int numElmt, int nquad0, int nquad1,
406 int nquad2, int nmodes0, int nmodes1, int nmodes2,
407 const Array<OneD, const NekDouble> &base0,
408 const Array<OneD, const NekDouble> &base1,
409 const Array<OneD, const NekDouble> &base2,
410 const Array<OneD, const NekDouble> &jac,
411 const Array<OneD, const NekDouble> &input,
412 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
413{
414 int totmodes = LibUtilities::StdPyrData::getNumberOfCoefficients(
415 nmodes0, nmodes1, nmodes2);
416 int totpoints = nquad0 * nquad1 * nquad2;
417 int cnt;
418 int mode, mode1;
419
420 ASSERTL1(wsp.size() >=
421 numElmt * (nquad1 * nquad2 * nmodes0 +
422 nquad2 * max(nquad0 * nquad1, nmodes0 * nmodes1)),
423 "Insufficient workspace size");
424
425 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
426
427 Array<OneD, NekDouble> wsp1 =
428 wsp + numElmt * nquad2 * (max(nquad0 * nquad1, nmodes0 * nmodes1));
429
430 // Perform iproduct with respect to the '0' direction
431 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
432 wsp.get(), nquad0, base0.get(), nquad0, 0.0, wsp1.get(),
433 nquad1 * nquad2 * numElmt);
434
435 // Inner product with respect to the '1' direction
436 mode = 0;
437 for (int i = 0; i < nmodes0; ++i)
438 {
439 Blas::Dgemm('T', 'N', nquad2 * numElmt, nmodes1, nquad1, 1.0,
440 wsp1.get() + i * nquad1 * nquad2 * numElmt, nquad1,
441 base1.get(), nquad1, 0.0,
442 wsp.get() + mode * nquad2 * numElmt, nquad2 * numElmt);
443 mode += nmodes1;
444 }
445
446 // Inner product with respect to the '2' direction
447 mode = mode1 = cnt = 0;
448 for (int i = 0; i < nmodes0; ++i)
449 {
450 for (int j = 0; j < nmodes1; ++j, ++cnt)
451 {
452 int ijmax = max(i, j);
453 Blas::Dgemm('T', 'N', nmodes2 - ijmax, numElmt, nquad2, 1.0,
454 base2.get() + mode * nquad2, nquad2,
455 wsp.get() + cnt * nquad2 * numElmt, nquad2, 0.0,
456 output.get() + mode1, totmodes);
457 mode += nmodes2 - ijmax;
458 mode1 += nmodes2 - ijmax;
459 }
460
461 // increment mode in case order1!=order2
462 for (int j = nmodes1; j < nmodes2; ++j)
463 {
464 int ijmax = max(i, j);
465 mode += nmodes2 - ijmax;
466 }
467 }
468
469 // fix for modified basis for top singular vertex component
470 // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
471 if (sortTopVertex)
472 {
473 for (int n = 0; n < numElmt; ++n)
474 {
475 // add in (1+c)/2 (1+b)/2 component
476 output[1 + n * totmodes] +=
477 Blas::Ddot(nquad2, base2.get() + nquad2, 1,
478 &wsp[nquad2 * numElmt + n * nquad2], 1);
479
480 // add in (1+c)/2 (1-b)/2 (1+a)/2 component
481 output[1 + n * totmodes] +=
482 Blas::Ddot(nquad2, base2.get() + nquad2, 1,
483 &wsp[nquad2 * nmodes1 * numElmt + n * nquad2], 1);
484
485 // add in (1+c)/2 (1+b)/2 (1+a)/2 component
486 output[1 + n * totmodes] += Blas::Ddot(
487 nquad2, base2.get() + nquad2, 1,
488 &wsp[nquad2 * (nmodes1 + 1) * numElmt + n * nquad2], 1);
489 }
490 }
491}
492
493/**
494 *
495 */
496void TetIProduct(bool sortTopEdge, int numElmt, int nquad0, int nquad1,
497 int nquad2, int nmodes0, int nmodes1, int nmodes2,
498 const Array<OneD, const NekDouble> &base0,
499 const Array<OneD, const NekDouble> &base1,
500 const Array<OneD, const NekDouble> &base2,
501 const Array<OneD, const NekDouble> &jac,
502 const Array<OneD, const NekDouble> &input,
503 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
504{
505 int totmodes = LibUtilities::StdTetData::getNumberOfCoefficients(
506 nmodes0, nmodes1, nmodes2);
507 int totpoints = nquad0 * nquad1 * nquad2;
508 int cnt;
509 int mode, mode1;
510
511 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
512
513 Array<OneD, NekDouble> wsp1 =
514 wsp +
515 nquad2 * numElmt *
516 (max(nquad0 * nquad1, nmodes0 * (2 * nmodes1 - nmodes0 + 1) / 2));
517
518 // Perform iproduct with respect to the '0' direction
519 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
520 wsp.get(), nquad0, base0.get(), nquad0, 0.0, wsp1.get(),
521 nquad1 * nquad2 * numElmt);
522
523 // Inner product with respect to the '1' direction
524 mode = 0;
525 for (int i = 0; i < nmodes0; ++i)
526 {
527 Blas::Dgemm('T', 'N', nquad2 * numElmt, nmodes1 - i, nquad1, 1.0,
528 wsp1.get() + i * nquad1 * nquad2 * numElmt, nquad1,
529 base1.get() + mode * nquad1, nquad1, 0.0,
530 wsp.get() + mode * nquad2 * numElmt, nquad2 * numElmt);
531 mode += nmodes1 - i;
532 }
533
534 // fix for modified basis by splitting top vertex mode
535 if (sortTopEdge)
536 {
537 // base singular vertex and singular edge (1+b)/2
538 // ((1+a)/2 components entry into (1+b)/2)
539 // Could be made into an mxm if we have specialised base1[1]
540 for (int n = 0; n < numElmt; ++n)
541 {
542 Blas::Dgemv('T', nquad1, nquad2, 1.0,
543 wsp1.get() + numElmt * nquad1 * nquad2 +
544 n * nquad1 * nquad2,
545 nquad1, base1.get() + nquad1, 1, 1.0,
546 wsp.get() + nquad2 * numElmt + n * nquad2, 1);
547 }
548 }
549
550 // Inner product with respect to the '2' direction
551 mode = mode1 = cnt = 0;
552 for (int i = 0; i < nmodes0; ++i)
553 {
554 for (int j = 0; j < nmodes1 - i; ++j, ++cnt)
555 {
556 Blas::Dgemm('T', 'N', nmodes2 - i - j, numElmt, nquad2, 1.0,
557 base2.get() + mode * nquad2, nquad2,
558 wsp.get() + cnt * nquad2 * numElmt, nquad2, 0.0,
559 output.get() + mode1, totmodes);
560 mode += nmodes2 - i - j;
561 mode1 += nmodes2 - i - j;
562 }
563
564 // increment mode in case order1!=order2
565 mode += (nmodes2 - nmodes1) * (nmodes2 - nmodes1 + 1) / 2;
566 }
567
568 // fix for modified basis for top singular vertex component
569 // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
570 if (sortTopEdge)
571 {
572 for (int n = 0; n < numElmt; ++n)
573 {
574 // add in (1+c)/2 (1+b)/2 component
575 output[1 + n * totmodes] +=
576 Blas::Ddot(nquad2, base2.get() + nquad2, 1,
577 &wsp[nquad2 * numElmt + n * nquad2], 1);
578
579 // add in (1+c)/2 (1-b)/2 (1+a)/2 component
580 output[1 + n * totmodes] +=
581 Blas::Ddot(nquad2, base2.get() + nquad2, 1,
582 &wsp[nquad2 * nmodes1 * numElmt + n * nquad2], 1);
583 }
584 }
585}
586
587} // namespace Nektar::Collections
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
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 = alpha A x plus beta y where A[m x n].
Definition: Blas.hpp:211
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:163
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:383
Nektar::Collections::TetIProduct
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)
Definition: IProduct.cpp:496
Nektar::Collections::PyrIProduct
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)
Definition: IProduct.cpp:405
Nektar::Collections::TriIProduct
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)
Definition: IProduct.cpp:128
Nektar::Collections::QuadIProduct
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)
Definition: IProduct.cpp:46
Nektar::Collections::PrismIProduct
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)
Definition: IProduct.cpp:338
Nektar::Collections::HexIProduct
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)
Definition: IProduct.cpp:170
Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:279
Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:232
Nektar::LibUtilities::StdTetData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:187
Nektar::LibUtilities::StdTriData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb)
Definition: ShapeType.hpp:109
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.hpp:72
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825
std
STL namespace.
Generated on Wed Oct 30 2024 16:07:27 for Nektar++ by doxygen 1.9.4