ASL 0.1.7
Advanced Simulation Library
Loading...
Searching...
No Matches
aslTemplates.h
Go to the documentation of this file.
1/*
2 * Advanced Simulation Library <http://asl.org.il>
3 *
4 * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
5 *
6 *
7 * This file is part of Advanced Simulation Library (ASL).
8 *
9 * ASL is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU Affero General Public License as
11 * published by the Free Software Foundation, version 3 of the License.
12 *
13 * ASL is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Affero General Public License for more details.
17 *
18 * You should have received a copy of the GNU Affero General Public License
19 * along with ASL. If not, see <http://www.gnu.org/licenses/>.
20 *
21 */
22
23
24#ifndef ASLTEMPLATES_H
25#define ASLTEMPLATES_H
26
27#include "aslVectors.h"
28//#include "aslSVectors.h"
29
30namespace asl {
31
84
85
87 class VectorTemplate
88 {
89 private:
90 void buildInvertVectorList();
91 public:
92 std::vector<AVec<int> > vectors;
93 std::vector<double> laplasCoefs;
94 std::vector<double> gradientCoefs;
95 std::vector<double> quasiparticlesCoefs;
96 std::vector<unsigned int> invertVectors;
97 double dIdJLapCoef;
98 std::vector<std::vector<double>> dxCoefs;
99 std::vector<std::vector<std::vector<double>>> dIdJCoefs;
101 VectorTemplate(int n, AVec<int>* vec, double* lc, double* gc);
102
103 inline unsigned int numberOfDimentions() const;
104 inline AVec<int> getInverVector(unsigned int i);
105 };
106
107 inline unsigned int nD(const VectorTemplate & vt);
108
110
116 const VectorTemplate & d1q2ec();
118
124 const VectorTemplate & d2q4ec();
125
127
133 const VectorTemplate & d3q8ec();
134
136
141 const VectorTemplate & d1q3();
142
144
149 const VectorTemplate & d2q5();
150
152
157 const VectorTemplate & d2q9();
158
160
165 const VectorTemplate & d3q7();
166
168
173 const VectorTemplate & d3q15();
174
176
181 const VectorTemplate & d3q19();
182
184
189 const VectorTemplate & d3q27();
190
192
197 const VectorTemplate & d1q1uv();
199
204 const VectorTemplate & d2q2uv();
205
207
212 const VectorTemplate & d3q3uv();
213
215
220 const VectorTemplate & d1q2();
221
223
228 const VectorTemplate & d2q4();
229
231
236 const VectorTemplate & d3q6();
237
239
242 const VectorTemplate & d2q8();
243
245
248 const VectorTemplate & d3q14();
249
251
254 const VectorTemplate & d3q18();
255
257
259 inline const VectorTemplate* nearestNeigboursVT(unsigned int dimNumber);
260
262
266 inline const VectorTemplate* nearestNeigboursVT0(unsigned int dimNumber);
267
269
271 inline const VectorTemplate* nearestNeigboursPVT(unsigned int dimNumber);
272
273
275
279 inline const VectorTemplate* allNeigboursVT(unsigned int dimNumber);
280
282
286 inline const VectorTemplate* elementaryCellVT(unsigned int dimNumber);
287
288
289// ----------------------------- Implementation -------------------------
290
291 inline unsigned int VectorTemplate::numberOfDimentions() const
292 {
293 return vectors[0].getSize();
294 }
295
296 inline unsigned int nD(const VectorTemplate & vt)
297 {
298 return vt.numberOfDimentions();
299 }
300
301
302 inline const VectorTemplate* nearestNeigboursVT(unsigned int dimNumber)
303 {
304 static const VectorTemplate* vt[3]={&d1q3(),&d2q5(),&d3q7()};
305 return vt[dimNumber-1];
306 }
307
308 inline const VectorTemplate* nearestNeigboursPVT(unsigned int dimNumber)
309 {
310 static const VectorTemplate* vt[3]={&d1q3(),&d2q9(),&d3q15()};
311 return vt[dimNumber-1];
312 }
313
314 inline const VectorTemplate* allNeigboursVT(unsigned int dimNumber)
315 {
316 static const VectorTemplate* vt[3]={&d1q3(),&d2q9(),&d3q27()};
317 return vt[dimNumber-1];
318 }
319
320 inline const VectorTemplate* elementaryCellVT(unsigned int dimNumber)
321 {
322 static const VectorTemplate* vt[3]={&d1q2ec(),&d2q4ec(),&d3q8ec()};
323 return vt[dimNumber-1];
324 }
325
326 inline AVec<int> VectorTemplate::getInverVector(unsigned int i)
327 {
328 return vectors[invertVectors[i]];
329 }
330
331/*
333 namespace templ {
335 class GrigTemplate{
336 public:
337 unsigned const int nDimentions;
338 unsigned const int nPoints;
339 virtual vector<int> & getVector(unsigned int i)=0;
340 protected:
341 GridTemplate(unsigned int nD, unsigned int nP);
342 }
343*/
349/* class d1q2ec {
350 public:
351 static const int ND=1;
352 static const int NV=2;
353 typedef Vec<ND,int> DV;
354 public:
355 inline static const DV & l(int i) {
356 static const DV lat[NV] = {DV(0),DV(1)};
357 return lat[i];
358 }
360 template <typename T>
361 inline static const T interpol(const Vec<NV,T> &d, const Vec<ND,lFl> &e) {
362 return d.x()*(1.-e.x())+d.y()*e.x();
363 }
364 };
365*/
367
372/* class d2q4ec {
373 public:
374 static const int ND=2;
375 static const int NV=4;
376 typedef Vec<ND,int> DV;
377 inline static const DV & l(int i) {
378 static const DV lat[NV] = {DV(0,0),DV(1,0),DV(0,1),DV(1,1)};
379 return lat[i];
380 }
382 template <typename T>
383 inline static const T interpol(const Vec<NV,T> &d, const Vec<ND,lFl> &e) {
384 return d[0]*(1.-e.x())*(1.-e.y())+d[1]*e.x()*(1.-e.y())+
385 d[2]*(1.-e.x())*e.y() +d[3]*e.x()*e.y();
386 }
387
388 };
389*/
391
396/* class d3q8ec {
397 public:
398 static const int ND=3;
399 static const int NV=8;
400 typedef Vec<ND,int> DV;
401 inline static const DV & l(int i) {
402 static const DV lat[NV] = {
403 DV(0,0,0),DV(1,0,0),DV(0,1,0),DV(1,1,0),
404 DV(0,0,1),DV(1,0,1),DV(0,1,1),DV(1,1,1)
405 };
406 return lat[i];
407 }
408
410 template <typename T>
411 inline static const T interpol(const Vec<NV,T> &d, const Vec<ND,lFl> &e) {
412 return d[0]*(1.-e.x())*(1.-e.y())*(1.-e.z())
413 +d[1]* e.x()* (1.-e.y())*(1.-e.z())
414 +d[2]*(1.-e.x())* e.y()* (1.-e.z())
415 +d[3]* e.x()* e.y()* (1.-e.z())
416 +d[4]*(1.-e.x())*(1.-e.y())* e.z()
417 +d[5]* e.x()* (1.-e.y())* e.z()
418 +d[6]*(1.-e.x())* e.y()* e.z()
419 +d[7]* e.x()* e.y()* e.z();
420 }
421 };
422
423*/
424
426
431/* class d2q9 {
432 public:
433 static const int ND=2;
434 static const int NV=9;
435 typedef Vec<ND,int> DV;
436 // private:
437 static const lFl w1=4./9.,w2=1./9.,w3=1./36., as2i=3.;
438 static inline const DV & l(int i) {
439 static const DV lat[NV] = {
440 DV(0,0),DV(1,0),DV(0,1), DV(-1,0),DV(0,-1),
441 DV(1,1),DV(-1,1),DV(-1,-1),DV(1,-1)
442 };
443 return lat[i];
444 }
446 static inline int io(int i) {
447 static const int inv[NV] = {0,3,4,1,2,7,8,5,6};
448 return inv[i];
449 }
450 static inline lFl s(const Vec<NV> &p) {
451 return (w1*p[0]+w2*(p[1]+p[2]+p[3]+p[4])+w3*(p[5]+p[6]+p[7]+p[8]));
452 }
453 static inline lFl s(Vec<NV> &p, const lFl &val) {
454 return (p[0] =p[1] =p[2] =p[3] =p[4] =p[5] =p[6] =p[7] =p[8] =val);
455 }
456
457 static inline const Vec<ND> v(const Vec<NV> &p) {
458 return Vec<2>(w2*(p[1]-p[3])+w3*(p[5]-p[6]-p[7]+p[8]),
459 w2*(p[2]-p[4])+w3*(p[5]+p[6]-p[7]-p[8]));
460 }
461 static inline const Vec<ND> v(Vec<NV> &p, const Vec<ND> &val) {
462 const lFl p0(s(p));
463 for (int i(0); i < NV; ++i)
464 p[i] =p0+val*Vec<ND>(l(i))*as2i;
465 return val;
466 }
467
469 static inline lFl lc(int i) {
470 static const lFl c[NV] = {-10./3.,2./3.,2./3.,2./3.,2./3.,1./6.,1./6.,1./6.,1./6.};
471 return c[i];
472 }
473
474 };
475*/
476
478
483/* class d2q5 {
484 public:
485 static const int ND=2;
486 static const int NV=5;
487 typedef Vec<ND,int> DV;
488 inline static const DV & l(int i) {
489 static const DV lat[NV] = {DV(0,0),DV(1,0),DV(0,1),DV(-1,0), DV(0,-1)};
490 return lat[i];
491 }
493 inline static int io(int i) {
494 static const int inv[NV] = {0,3,4,1,2};
495 return inv[i];
496 }
498 static inline lFl lc(int i) {
499 static const lFl c[NV] = {-4.,1.,1.,1.,1.};
500 return c[i];
501 }
502 };
503*/
504
506
511/* class d2q4 {
512 public:
513 static const int ND=2;
514 static const int NV=4;
515 typedef Vec<ND,int> DV;
516 static const lFl w1=1./NV, as2i=ND;
517 inline static const DV & l(int i) {
518 static const DV lat[NV] = {DV(1,0),DV(0,1),DV(-1,0), DV(0,-1)};
519 return lat[i];
520 }
522 inline static int io(int i) {
523 static const int inv[NV] = {2,3,0,1};
524 return inv[i];
525 }
526 static inline lFl s(const Vec<NV> &p) {return (w1*(p[0]+p[1]+p[2]+p[3]));}
527 static inline lFl s(Vec<NV> &p, const lFl &val) {return (p[0] =p[1] =p[2] =p[3] =val);}
528 static inline const Vec<ND> v(const Vec<NV> &p) {
529 return Vec<ND>(w1*(p[0]-p[2]),w1*(p[1]-p[3]));
530 }
531 static inline const Vec<ND> v(Vec<NV> &p, const Vec<ND> &val) {
532 const lFl p0(s(p));
533 for (int i(0); i < NV; ++i)p[i] =p0+val*Vec<ND>(l(i))*as2i;
534 return val;
535 }
536
537 };
538
539*/
540
542
546/* class d3q7 {
547 public:
548 static const int ND=3;
549 static const int NV=7;
550 typedef Vec<ND,int> DV;
551 inline static const DV l(int i) {
552 static const DV lat[NV] = {DV(SV()[I2T<0>()]),DV(SV()[I2T<1>()]),DV(SV()[I2T<2>()]),
553 DV(SV()[I2T<3>()]),DV(SV()[I2T<4>()]),DV(SV()[I2T<5>()]),
554 DV(SV()[I2T<6>()])};
555 return lat[i];
556 }
558 inline static int io(int i) {
559 static const int inv[NV] = {0,4,5,6,1,2,3};
560 return inv[i];
561 }
563 static inline lFl lc(int i) {
564 static const lFl c[NV] = {-6.,1.,1.,1.,1.,1.,1.};
565 return c[i];
566 }
567 };
568*/
569
571
575/* class d3q6 {
576 public:
577 static const int ND=3;
578 static const int NV=6;
579 typedef Vec<ND,int> DV;
580 static const lFl w1=1./NV, as2i=ND;
581 inline static const DV & l(int i) {
582 static const DV lat[NV] = {
583 DV(1,0,0), DV(0,1,0),DV(0,0,1),
584 DV(-1,0,0), DV(0,-1,0),DV(0,0,-1)
585 };
586 return lat[i];
587 }
589 inline static int io(int i) {
590 static const int inv[NV] = {3,4,5,0,1,2};
591 return inv[i];
592 }
593 static inline lFl s(const Vec<NV> &p) {return (w1*(p[0]+p[1]+p[2]+p[3]+p[4]+p[5]));}
594 static inline lFl s(Vec<NV> &p, const lFl &val) {
595 return (p[0] =p[1] =p[2] =p[3] =p[4] =p[5] =val);
596 }
597 static inline const Vec<ND> v(const Vec<NV> &p) {
598 return Vec<ND>(w1*(p[0]-p[3]),w1*(p[1]-p[4]),w1*(p[2]-p[5]));
599 }
600 static inline const Vec<ND> v(Vec<NV> &p, const Vec<ND> &val) {
601 const lFl p0(s(p));
602 for (int i(0); i < NV; ++i)p[i] =p0+val*Vec<ND>(l(i))*as2i;
603 return val;
604 }
605 };
606
607*/
608
610
614/* class d3q19 {
615 public:
616 static const int ND=3;
617 static const int NV=19;
618 typedef Vec<ND,int> DV;
619 static const lFl w1=1./3.,w2=1./18.,w3=1./36., as2i=3.;
620 inline static const DV & l(int i) {
621 static const DV lat[NV] = {
622 DV(0,0,0), DV(1,0,0), DV(0,1,0),
623 DV(0,0,1), DV(-1,0,0), DV(0,-1,0),
624 DV(0,0,-1), DV(1,1,0), DV(1,-1,0),
625 DV(-1,-1,0), DV(-1,1,0), DV(0,1,1),
626 DV(0,1,-1), DV(0,-1,-1), DV(0,-1,1),
627 DV(1,0,1), DV(1,0,-1), DV(-1,0,-1),
628 DV(-1,0,1)
629 };
630 return lat[i];
631 }
633 inline static int io(int i) {
634 static const int inv[NV] = {0,4,5,6,1,2,3,9,10,7,8,13,14,11,12,17,18,15,16};
635 return inv[i];
636 }
637 static inline lFl s(const Vec<NV> &p) {
638 return (w1*p[0]+w2*(p[1]+p[2]+p[3]+p[4]+p[5]+p[6])
639 +w3*(p[7]+p[8]+p[9]+p[10]+p[11]+p[12]+p[13]+p[14]+p[15]+p[16]+p[17]+p[18]));
640 }
641 static inline lFl s(Vec<NV> &p, const lFl &val) {p=val; return val;}
642
643 static inline const Vec<ND> v(const Vec<NV> &p) {
644 return
645 Vec<ND>(w2*(p[1]-p[4])+w3*( p[7] +p[8]- p[9]-p[10]+p[15]+p[16]-p[17]-p[18]),
646 w2*(p[2]-p[5])+w3*( p[7] -p[8]- p[9]+p[10]+p[11]+p[12]-p[13]-p[14]),
647 w2*(p[3]-p[6])+w3*(p[11]-p[12]-p[13]+p[14]+p[15]-p[16]-p[17]+p[18]));
648 }
649 static inline const Vec<ND> v(Vec<NV> &p, const Vec<ND> &val) {
650 const lFl p0(s(p));
651 for (int i(0); i < NV; ++i)p[i] =p0+val*Vec<ND>(l(i))*as2i;
652 return val;
653 }
655 static inline lFl lc(int i) {
656 static const lFl c[NV] = {-4.,
657 1./3.,1./3.,1./3.,1./3.,1./3.,1./3.,
658 1./6.,1./6.,1./6.,1./6.,1./6.,1./6.,
659 1./6.,1./6.,1./6.,1./6.,1./6.,1./6.};
660 return c[i];
661 }
662 };
663*/
664
666
670/* class d3q15 {
671 public:
672 static const int ND=3;
673 static const int NV=15;
674 typedef Vec<ND,int> DV;
675 static const lFl w1=2./9.,w2=1./9.,w3=1./72., as2i=3.;
676 static inline const DV & l(int i) {
677 static const DV lat[NV] = {
678 DV(0,0,0), DV(1,0,0), DV(0,1,0),
679 DV(0,0,1), DV(-1,0,0), DV(0,-1,0),
680 DV(0,0,-1), DV(1,1,1), DV(1,1,-1),
681 DV(1,-1,1), DV(1,-1,-1), DV(-1,1,1),
682 DV(-1,1,-1), DV(-1,-1,1), DV(-1,-1,-1)
683 };
684 return lat[i];
685 }
687 static inline int io(int i) {
688 static const int inv[NV] = {0,4,5,6,1,2,3,14,13,12,11,10,9,8,7};
689 return inv[i];
690 }
691 static inline lFl s(const Vec<NV> &p) {
692 return (w1*p[0]+w2*(p[1]+p[2]+p[3]+p[4]+p[5]+p[6])
693 +w3*(p[7]+p[8]+p[9]+p[10]+p[11]+p[12]+p[13]+p[14]));
694 }
695 static inline lFl s(Vec<NV> &p, const lFl &val) {p=val; return val;}
696
697 template <typename Td,typename SD>
698 static inline const Vec<ND> v(const Vec<NV,Td,SD> &p)
699 {
700 return
701 Vec<ND>(w2*(p[1]-p[4])+w3*(p[7]+p[8]+p[9]+p[10]-p[11]-p[12]-p[13]-p[14]),
702 w2*(p[2]-p[5])+w3*(p[7]+p[8]-p[9]-p[10]+p[11]+p[12]-p[13]-p[14]),
703 w2*(p[3]-p[6])+w3*(p[7]-p[8]+p[9]-p[10]+p[11]-p[12]+p[13]-p[14]));
704 }
705 static inline void v(Vec<NV> &p, const Vec<ND> &val) {
706 const lFl p0(s(p));
707 for (int i(0); i < NV; ++i)p[i] =p0+val*Vec<ND>(l(i))*as2i;
708 }
709 template <typename Ty>
710 static inline void v(Vec<NV,lFl,Ty> p, const Vec<ND> &val)
711 {
712 const lFl p0(s(p));
713 for (int i(0); i < NV; ++i)p[i] =p0+val*Vec<ND>(l(i))*as2i;
714 }
715
717 static inline lFl lc(int i) {
718 static const lFl c[NV] = {-14./3.,
719 2./3.,2./3.,2./3.,2./3.,2./3.,2./3.,
720 1./12.,1./12.,1./12.,1./12.,
721 1./12.,1./12.,1./12.,1./12.};
722 return c[i];
723 }
724 };
725*/
726
728
732/* class d3q27 {
733 public:
734 static const int ND=3;
735 static const int NV=27;
736 typedef Vec<ND,int> DV;
737 inline static const DV & l(int i) {
738 static const DV lat[NV] = {
739 DV(0,0,0), DV(1,0,0), DV(0,1,0),
740 DV(0,0,1), DV(-1,0,0), DV(0,-1,0),
741 DV(0,0,-1), DV(1,1,0), DV(1,-1,0),
742 DV(-1,-1,0), DV(-1,1,0), DV(0,1,1),
743 DV(0,1,-1), DV(0,-1,-1), DV(0,-1,1),
744 DV(1,0,1), DV(1,0,-1), DV(-1,0,-1),
745 DV(-1,0,1), DV(1,1,1), DV(1,1,-1),
746 DV(1,-1,1), DV(1,-1,-1), DV(-1,1,1),
747 DV(-1,1,-1), DV(-1,-1,1), DV(-1,-1,-1)
748 };
749 return lat[i];
750 }
752 inline static int io(int i) {
753 static const int inv[NV] = {0,
754 4,5,6,1,2,3,
755 9,10,7,8,13,14,11,12,17,18,15,16,
756 26,25,24,23,22,21,20,19};
757 return inv[i];
758 }
759 };
760*/
761
763
767/* class d1q3 {
768 public:
769 static const int ND=1; ///<number of dimensions
770 static const int NV=3; ///<nuber of directions
771 typedef Vec<ND,int> DV; ///< type of lattice vector
772 inline static const DV & l(int i) { /// Returns value of the lattice vector
773 static const DV lat[NV] = {DV(0),DV(1),DV(-1)};
774 return lat[i];
775 }
777 inline static int io(int i) {
778 static const int inv[NV] = {0,2,1};
779 return inv[i];
780 }
781 };
782*/
783
785
789/* class d1q2 {
790 public:
791 static const int ND=1; ///<number of dimensions
792 static const int NV=2; ///<nuber of directions
793 typedef Vec<1,int> DV; ///< type of lattice vector
794 inline static const DV & l(int i) { /// Returns value of the lattice vector
795 static const DV lat[NV] = {DV(1),DV(-1)};
796 return lat[i];
797 }
799 inline static int io(int i) {
800 static const int inv[NV] = {1,0};
801 return inv[i];
802 }
803 };
804
806 template <typename Tl> inline Vec<Tl::NV> lrv(const Vec<Tl::NV> &f_) {
807 Vec<Tl::NV> a;
808 for (int i(0); i < Tl::NV; ++i) {a[i] =f_[Tl::io(i)];}
809 return a;
810 }
811
812 template <typename Tl,int I> inline void _l1f_c(I2T<I>,Tl, const Vec<Tl::ND> &v_,Vec<Tl::NV> &a){
813 typedef typename Tl::SV SV;
814 a[I] =SV()[I2T<I>()]*v_; _l1f_c(I2T<I-1>(),Tl(),v_,a);
815 }
816 template <typename Tl> inline void _l1f_c(I2T<0>,Tl, const Vec<Tl::ND> &v_,Vec<Tl::NV> &a){
817 typedef typename Tl::SV SV;
818 a[0] =SV()[I2T<0>()]*v_;
819 }
820
822 template <typename Tl> inline Vec<Tl::NV> l1f(const Vec<Tl::ND> &v_) {
823 typedef Vec<Tl::ND> TV;
824 Vec<Tl::NV> a;
825 // for (int i(0); i < Tl::NV; ++i) {a[i] =TV(Tl::l(i))*v_;}
826 _l1f_c(I2T<Tl::NV-1>(),Tl(),v_,a);
827 return a;
828 }
829
830 template <typename Tl,int I>
831 inline void _l2f_c(I2T<I>,Tl, const Vec<Tl::ND> &v1_, const Vec<Tl::ND> &v2_,Vec<Tl::NV> &a){
832 class Tl::SV q; a[I] =(q[I2T<I>()]*v1_)*(q[I2T<I>()]*v2_); _l2f_c(I2T<I-1>(),Tl(),v1_,v2_,a);
833 }
834 template <typename Tl>
835 inline void _l2f_c(I2T<0>,Tl, const Vec<Tl::ND> &v1_, const Vec<Tl::ND> &v2_,Vec<Tl::NV> &a){
836 class Tl::SV q; a[0] =(q[I2T<0>()]*v1_)*(q[I2T<0>()]*v2_);
837 }
838
840 template <typename Tl> inline Vec<Tl::NV> l2f(const Vec<Tl::ND> &v1_, const Vec<Tl::ND> &v2_) {
841 typedef Vec<Tl::ND> TV;
842 Vec<Tl::NV> a;
843 // for (int i(0); i < Tl::NV; ++i) {a[i] =(TV(Tl::l(i))*v1_)*(TV(Tl::l(i))*v2_);}
844 _l2f_c(I2T<Tl::NV-1>(),Tl(),v1_,v2_,a);
845 return a;
846 }
847
848
849 } // templ
850*/
851}// asl
852
853#endif // TEMPL_H_INCLUDED
Defines set of vectros with several properties.
std::vector< double > quasiparticlesCoefs
VectorTemplate(int n, AVec< int > *vec)
std::vector< std::vector< std::vector< double > > > dIdJCoefs
std::vector< AVec< int > > vectors
VectorTemplate(int n, AVec< int > *vec, double *lc, double *gc)
unsigned int numberOfDimentions() const
AVec< int > getInverVector(unsigned int i)
std::vector< double > laplasCoefs
std::vector< std::vector< double > > dxCoefs
std::vector< unsigned int > invertVectors
std::vector< double > gradientCoefs
const unsigned int nD(const Block &b)
Definition aslBlocks.h:220
SPDataWrapperACLData generateDataContainerACL_SP(const Block &b, unsigned int n=1)
generates pointer to ACL Data field with n components
const VectorTemplate & d1q2ec()
An elementary cell in 1D space.
const VectorTemplate & d2q4ec()
An elementary cell in 2D space.
const VectorTemplate & d3q8ec()
An elementary cell in 3D space.
const VectorTemplate * allNeigboursVT(unsigned int dimNumber)
returns template corresponding to all neighbours
const VectorTemplate * nearestNeigboursVT0(unsigned int dimNumber)
returns template corresponding to nearest neighbours without central point
const VectorTemplate & d3q3uv()
An elementary cell in 3D space.
const VectorTemplate * nearestNeigboursPVT(unsigned int dimNumber)
returns template corresponding to nearest neighbours plus
const VectorTemplate * nearestNeigboursVT(unsigned int dimNumber)
returns template corresponding to nearest neighbours
const VectorTemplate & d2q2uv()
An elementary cell in 2D space.
const VectorTemplate * elementaryCellVT(unsigned int dimNumber)
returns template corresponding to an elementary cell
const VectorTemplate & d2q4()
Vector template.
const VectorTemplate & d1q2()
Vector template.
const VectorTemplate & d3q6()
Vector template.
const VectorTemplate & d1q3()
Vector template.
const VectorTemplate & d3q7()
Vector template.
const VectorTemplate & d2q5()
Vector template.
const VectorTemplate & d2q8()
Vector template.
const VectorTemplate & d3q18()
Vector template.
const VectorTemplate & d3q14()
Vector template.
const VectorTemplate & d3q19()
Vector template.
const VectorTemplate & d3q27()
Vector template.
const VectorTemplate & d3q15()
Vector template.
const VectorTemplate & d1q1uv()
An unit vector in 1D space.
const VectorTemplate & d2q9()
Vector template.
Advanced Simulation Library.
Definition aslDataInc.h:31
VTName
list of implemented names of VectorTemplate
@ VTN_D2Q5
@ VTN_D3Q14
@ VTN_D3Q7
@ VTN_D3Q27
@ VTN_D1Q2
@ VTN_D1Q2EC
@ VTN_D2Q4
@ VTN_D3Q8EC
@ VTN_D3Q3UV
@ VTN_D3Q6
@ VTN_D2Q8
@ VTN_D3Q18
@ VTN_D3Q19
@ VTN_D3Q15
@ VTN_D1Q1UV
@ VTN_D2Q9
@ VTN_D2Q2UV
@ VTN_D2Q4EC
@ VTN_D1Q3
definition of class АVec<T>