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.data(), 1, output.data(), 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.data(), 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.data(), nquad1, 0.0,
96 &wsp[0], 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.data(), 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.data(), 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.data() + mode * nquad1, nquad1,
153 wsp1.data() + 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.data() + nquad1 * numElmt,
163 nquad1, base1.data() + nquad1, 1, 1.0, &output[1],
164 totmodes);
165 }
166}
167
168/**
169 *
170 */
171void HexIProduct(bool colldir0, bool colldir1, bool colldir2, int numElmt,
172 int nquad0, int nquad1, int nquad2, int nmodes0, int nmodes1,
173 int nmodes2, const Array<OneD, const NekDouble> &base0,
174 const Array<OneD, const NekDouble> &base1,
175 const Array<OneD, const NekDouble> &base2,
176 const Array<OneD, const NekDouble> &jac,
177 const Array<OneD, const NekDouble> &input,
178 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
179{
180 int totmodes = nmodes0 * nmodes1 * nmodes2;
181 int totpoints = nquad0 * nquad1 * nquad2;
182
183 if (colldir0 && colldir1 && colldir2)
184 {
185
186 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, output, 1);
187 }
188 else
189 {
190 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
191
192 // Assign second half of workspace for 2nd DGEMM operation.
193 Array<OneD, NekDouble> wsp1 = wsp + totpoints * numElmt;
194
195 // note sure what criterion we should use to swap around these
196 // strategies
197 if (numElmt < nmodes0 || 1)
198 {
199 Array<OneD, NekDouble> wsp2 = wsp1 + nmodes0 * nquad1 * nquad2;
200
201 // loop over elements
202 for (int n = 0; n < numElmt; ++n)
203 {
204 if (colldir0)
205 {
206 for (int i = 0; i < nmodes0; ++i)
207 {
208 Vmath::Vcopy(nquad1 * nquad2, &wsp[n * totpoints] + i,
209 nquad0, wsp1.data() + nquad1 * nquad2 * i,
210 1);
211 }
212 }
213 else
214 {
215 Blas::Dgemm('T', 'N', nquad1 * nquad2, nmodes0, nquad0, 1.0,
216 &wsp[n * totpoints], nquad0, base0.data(),
217 nquad0, 0.0, wsp1.data(), nquad1 * nquad2);
218 }
219
220 if (colldir1)
221 {
222 // reshuffle data for next operation.
223 for (int i = 0; i < nmodes1; ++i)
224 {
225 Vmath::Vcopy(nquad2 * nmodes0, wsp1.data() + i, nquad1,
226 wsp2.data() + nquad2 * nmodes0 * i, 1);
227 }
228 }
229 else
230 {
231 Blas::Dgemm('T', 'N', nquad2 * nmodes0, nmodes1, nquad1,
232 1.0, wsp1.data(), nquad1, base1.data(), nquad1,
233 0.0, wsp2.data(), nquad2 * nmodes0);
234 }
235
236 if (colldir2)
237 {
238 // reshuffle data for next operation.
239 for (int i = 0; i < nmodes2; ++i)
240 {
241 Vmath::Vcopy(
242 nmodes0 * nmodes1, wsp2.data() + i, nquad2,
243 &output[n * totmodes] + nmodes0 * nmodes1 * i, 1);
244 }
245 }
246 else
247 {
248 Blas::Dgemm('T', 'N', nmodes0 * nmodes1, nmodes2, nquad2,
249 1.0, wsp2.data(), nquad2, base2.data(), nquad2,
250 0.0, &output[n * totmodes], nmodes0 * nmodes1);
251 }
252 }
253 }
254 else
255 {
256 Array<OneD, NekDouble> wsp2 =
257 wsp1 + numElmt * (max(totpoints, totmodes));
258
259 if (colldir0)
260 {
261 for (int i = 0; i < nquad0; ++i)
262 {
263 Vmath::Vcopy(nquad1 * nquad2 * numElmt, &wsp[i], nquad0,
264 &wsp1[i * nquad1 * nquad2 * numElmt], 1);
265 }
266 }
267 else
268 {
269 // large degmm but copy at end.
270 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0,
271 nquad0, 1.0, &wsp[0], nquad0, base0.data(), nquad0,
272 0.0, &wsp1[0], nquad1 * nquad2 * numElmt);
273 }
274
275 if (colldir1)
276 {
277 for (int i = 0; i < nquad1; ++i)
278 {
279 Vmath::Vcopy(nquad2 * numElmt * nmodes0, &wsp1[i], nquad1,
280 &wsp2[i * nquad2 * numElmt * nmodes0], 1);
281 }
282 }
283 else
284 {
285 Blas::Dgemm('T', 'N', nquad2 * numElmt * nmodes0, nmodes1,
286 nquad1, 1.0, &wsp1[0], nquad1, base1.data(), nquad1,
287 0.0, &wsp2[0], nquad2 * numElmt * nmodes0);
288 }
289
290 if (numElmt > 1)
291 {
292 if (colldir2)
293 {
294 for (int i = 0; i < nquad2; ++i)
295 {
296 Vmath::Vcopy(nmodes0 * nmodes1, &wsp2[i], nquad2,
297 &output[i * nmodes0 * nmodes1], 1);
298 }
299 }
300 else
301 {
302 Blas::Dgemm('T', 'N', numElmt * nmodes0 * nmodes1, nmodes2,
303 nquad2, 1.0, &wsp2[0], nquad2, base2.data(),
304 nquad2, 0.0, &wsp1[0],
305 numElmt * nmodes0 * nmodes1);
306 }
307
308 for (int i = 0; i < totmodes; ++i)
309 {
310 Vmath::Vcopy(numElmt, &wsp1[i * numElmt], 1, &output[i],
311 totmodes);
312 }
313 }
314 else
315 {
316 if (colldir2)
317 {
318 for (int i = 0; i < nquad2; ++i)
319 {
320 Vmath::Vcopy(nmodes0 * nmodes1, &wsp2[i], nquad2,
321 &output[i * nmodes0 * nmodes1], 1);
322 }
323 }
324 else
325 {
326 Blas::Dgemm('T', 'N', numElmt * nmodes0 * nmodes1, nmodes2,
327 nquad2, 1.0, &wsp2[0], nquad2, base2.data(),
328 nquad2, 0.0, &output[0],
329 numElmt * nmodes0 * nmodes1);
330 }
331 }
332 }
333 }
334}
335
336/**
337 *
338 */
339void PrismIProduct(bool sortTopVertex, int numElmt, int nquad0, int nquad1,
340 int nquad2, int nmodes0, int nmodes1, int nmodes2,
341 const Array<OneD, const NekDouble> &base0,
342 const Array<OneD, const NekDouble> &base1,
343 const Array<OneD, const NekDouble> &base2,
344 const Array<OneD, const NekDouble> &jac,
345 const Array<OneD, const NekDouble> &input,
346 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
347{
348 int totmodes = LibUtilities::StdPrismData::getNumberOfCoefficients(
349 nmodes0, nmodes1, nmodes2);
350 int totpoints = nquad0 * nquad1 * nquad2;
351 int cnt;
352 int mode, mode1;
353
354 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
355
356 Array<OneD, NekDouble> wsp1 =
357 wsp + numElmt * nquad2 * (max(nquad0 * nquad1, nmodes0 * nmodes1));
358
359 // Perform iproduct with respect to the '0' direction
360 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
361 wsp.data(), nquad0, base0.data(), nquad0, 0.0, wsp1.data(),
362 nquad1 * nquad2 * numElmt);
363
364 // Perform iproduct with respect to the '1' direction
365 Blas::Dgemm('T', 'N', nquad2 * numElmt * nmodes0, nmodes1, nquad1, 1.0,
366 wsp1.data(), nquad1, base1.data(), nquad1, 0.0, wsp.data(),
367 nquad2 * numElmt * nmodes0);
368
369 // Inner product with respect to the '2' direction (not sure if it would
370 // be better to swap loops?)
371 mode = mode1 = cnt = 0;
372 for (int i = 0; i < nmodes0; ++i)
373 {
374 cnt = i * nquad2 * numElmt;
375 for (int j = 0; j < nmodes1; ++j)
376 {
377 Blas::Dgemm('T', 'N', nmodes2 - i, numElmt, nquad2, 1.0,
378 base2.data() + mode * nquad2, nquad2,
379 wsp.data() + j * nquad2 * numElmt * nmodes0 + cnt,
380 nquad2, 0.0, output.data() + mode1, totmodes);
381 mode1 += nmodes2 - i;
382 }
383 mode += nmodes2 - i;
384 }
385
386 // fix for modified basis by splitting top vertex mode
387 if (sortTopVertex)
388 {
389 // top singular vertex
390 // ((1+a)/2 components entry into (1+c)/2)
391 // Could be made into an mxv if we have specialised base1[1]
392 for (int j = 0; j < nmodes1; ++j)
393 {
394 Blas::Dgemv('T', nquad2, numElmt, 1.0,
395 wsp.data() + j * nquad2 * numElmt * nmodes0 +
396 nquad2 * numElmt,
397 nquad2, base2.data() + nquad2, 1, 1.0,
398 &output[j * nmodes2 + 1], totmodes);
399 }
400 }
401}
402
403/**
404 *
405 */
406void PyrIProduct(bool sortTopVertex, int numElmt, int nquad0, int nquad1,
407 int nquad2, int nmodes0, int nmodes1, int nmodes2,
408 const Array<OneD, const NekDouble> &base0,
409 const Array<OneD, const NekDouble> &base1,
410 const Array<OneD, const NekDouble> &base2,
411 const Array<OneD, const NekDouble> &jac,
412 const Array<OneD, const NekDouble> &input,
413 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
414{
415 int totmodes = LibUtilities::StdPyrData::getNumberOfCoefficients(
416 nmodes0, nmodes1, nmodes2);
417 int totpoints = nquad0 * nquad1 * nquad2;
418 int cnt;
419 int mode, mode1;
420
421 ASSERTL1(wsp.size() >=
422 numElmt * (nquad1 * nquad2 * nmodes0 +
423 nquad2 * max(nquad0 * nquad1, nmodes0 * nmodes1)),
424 "Insufficient workspace size");
425
426 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
427
428 Array<OneD, NekDouble> wsp1 =
429 wsp + numElmt * nquad2 * (max(nquad0 * nquad1, nmodes0 * nmodes1));
430
431 // Perform iproduct with respect to the '0' direction
432 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
433 wsp.data(), nquad0, base0.data(), nquad0, 0.0, wsp1.data(),
434 nquad1 * nquad2 * numElmt);
435
436 // Inner product with respect to the '1' direction
437 mode = 0;
438 for (int i = 0; i < nmodes0; ++i)
439 {
440 Blas::Dgemm('T', 'N', nquad2 * numElmt, nmodes1, nquad1, 1.0,
441 wsp1.data() + i * nquad1 * nquad2 * numElmt, nquad1,
442 base1.data(), nquad1, 0.0,
443 wsp.data() + mode * nquad2 * numElmt, nquad2 * numElmt);
444 mode += nmodes1;
445 }
446
447 // Inner product with respect to the '2' direction
448 mode = mode1 = cnt = 0;
449 for (int i = 0; i < nmodes0; ++i)
450 {
451 for (int j = 0; j < nmodes1; ++j, ++cnt)
452 {
453 int ijmax = max(i, j);
454 Blas::Dgemm('T', 'N', nmodes2 - ijmax, numElmt, nquad2, 1.0,
455 base2.data() + mode * nquad2, nquad2,
456 wsp.data() + cnt * nquad2 * numElmt, nquad2, 0.0,
457 output.data() + mode1, totmodes);
458 mode += nmodes2 - ijmax;
459 mode1 += nmodes2 - ijmax;
460 }
461
462 // increment mode in case order1!=order2
463 for (int j = nmodes1; j < nmodes2; ++j)
464 {
465 int ijmax = max(i, j);
466 mode += nmodes2 - ijmax;
467 }
468 }
469
470 // fix for modified basis for top singular vertex component
471 // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
472 if (sortTopVertex)
473 {
474 for (int n = 0; n < numElmt; ++n)
475 {
476 // add in (1+c)/2 (1+b)/2 component
477 output[1 + n * totmodes] +=
478 Blas::Ddot(nquad2, base2.data() + nquad2, 1,
479 &wsp[nquad2 * numElmt + n * nquad2], 1);
480
481 // add in (1+c)/2 (1-b)/2 (1+a)/2 component
482 output[1 + n * totmodes] +=
483 Blas::Ddot(nquad2, base2.data() + nquad2, 1,
484 &wsp[nquad2 * nmodes1 * numElmt + n * nquad2], 1);
485
486 // add in (1+c)/2 (1+b)/2 (1+a)/2 component
487 output[1 + n * totmodes] += Blas::Ddot(
488 nquad2, base2.data() + nquad2, 1,
489 &wsp[nquad2 * (nmodes1 + 1) * numElmt + n * nquad2], 1);
490 }
491 }
492}
493
494/**
495 *
496 */
497void TetIProduct(bool sortTopEdge, int numElmt, int nquad0, int nquad1,
498 int nquad2, int nmodes0, int nmodes1, int nmodes2,
499 const Array<OneD, const NekDouble> &base0,
500 const Array<OneD, const NekDouble> &base1,
501 const Array<OneD, const NekDouble> &base2,
502 const Array<OneD, const NekDouble> &jac,
503 const Array<OneD, const NekDouble> &input,
504 Array<OneD, NekDouble> &output, Array<OneD, NekDouble> &wsp)
505{
506 int totmodes = LibUtilities::StdTetData::getNumberOfCoefficients(
507 nmodes0, nmodes1, nmodes2);
508 int totpoints = nquad0 * nquad1 * nquad2;
509 int cnt;
510 int mode, mode1;
511
512 Vmath::Vmul(numElmt * totpoints, jac, 1, input, 1, wsp, 1);
513
514 Array<OneD, NekDouble> wsp1 =
515 wsp +
516 nquad2 * numElmt *
517 (max(nquad0 * nquad1, nmodes0 * (2 * nmodes1 - nmodes0 + 1) / 2));
518
519 // Perform iproduct with respect to the '0' direction
520 Blas::Dgemm('T', 'N', nquad1 * nquad2 * numElmt, nmodes0, nquad0, 1.0,
521 wsp.data(), nquad0, base0.data(), nquad0, 0.0, wsp1.data(),
522 nquad1 * nquad2 * numElmt);
523
524 // Inner product with respect to the '1' direction
525 mode = 0;
526 for (int i = 0; i < nmodes0; ++i)
527 {
528 Blas::Dgemm('T', 'N', nquad2 * numElmt, nmodes1 - i, nquad1, 1.0,
529 wsp1.data() + i * nquad1 * nquad2 * numElmt, nquad1,
530 base1.data() + mode * nquad1, nquad1, 0.0,
531 wsp.data() + mode * nquad2 * numElmt, nquad2 * numElmt);
532 mode += nmodes1 - i;
533 }
534
535 // fix for modified basis by splitting top vertex mode
536 if (sortTopEdge)
537 {
538 // base singular vertex and singular edge (1+b)/2
539 // ((1+a)/2 components entry into (1+b)/2)
540 // Could be made into an mxm if we have specialised base1[1]
541 for (int n = 0; n < numElmt; ++n)
542 {
543 Blas::Dgemv('T', nquad1, nquad2, 1.0,
544 wsp1.data() + numElmt * nquad1 * nquad2 +
545 n * nquad1 * nquad2,
546 nquad1, base1.data() + nquad1, 1, 1.0,
547 wsp.data() + nquad2 * numElmt + n * nquad2, 1);
548 }
549 }
550
551 // Inner product with respect to the '2' direction
552 mode = mode1 = cnt = 0;
553 for (int i = 0; i < nmodes0; ++i)
554 {
555 for (int j = 0; j < nmodes1 - i; ++j, ++cnt)
556 {
557 Blas::Dgemm('T', 'N', nmodes2 - i - j, numElmt, nquad2, 1.0,
558 base2.data() + mode * nquad2, nquad2,
559 wsp.data() + cnt * nquad2 * numElmt, nquad2, 0.0,
560 output.data() + mode1, totmodes);
561 mode += nmodes2 - i - j;
562 mode1 += nmodes2 - i - j;
563 }
564
565 // increment mode in case order1!=order2
566 mode += (nmodes2 - nmodes1) * (nmodes2 - nmodes1 + 1) / 2;
567 }
568
569 // fix for modified basis for top singular vertex component
570 // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
571 if (sortTopEdge)
572 {
573 for (int n = 0; n < numElmt; ++n)
574 {
575 // add in (1+c)/2 (1+b)/2 component
576 output[1 + n * totmodes] +=
577 Blas::Ddot(nquad2, base2.data() + nquad2, 1,
578 &wsp[nquad2 * numElmt + n * nquad2], 1);
579
580 // add in (1+c)/2 (1-b)/2 (1+a)/2 component
581 output[1 + n * totmodes] +=
582 Blas::Ddot(nquad2, base2.data() + nquad2, 1,
583 &wsp[nquad2 * nmodes1 * numElmt + n * nquad2], 1);
584 }
585 }
586}
587
588} // 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:497
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:406
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:339
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:171
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 May 28 2025 19:03:34 for Nektar++ by doxygen 1.9.4