seams-core v2.14.0
libyodaLib, the C++ engine of d-SEAMS
Loading...
Searching...
No Matches
seams::ylm Namespace Reference

Functions

bool avx512Kernels ()
void ylm12AddBonds (const double *dx, const double *dy, const double *dz, int n, double *qlmInterleaved)
void ylmBatch (int orderL, const double *dx, const double *dy, const double *dz, int n, double *re, double *im)
void ylmAdd8 (int orderL, const double *dx, const double *dy, const double *dz, double *accA, double *accB)
bool ylmSumRows4 (int orderL, const double *dx, const double *dy, const double *dz, double *rows, int stride, int nKeep)
bool ylmLocalQl (int orderL, const double *dx, const double *dy, const double *dz, int nbonds, const int *nUsed, double prefactor, double *ql)
template<class T>
T legendrePoly (int orderL, int absM, const T *zpow)
template<class T>
void evalUnit (int orderL, T x, T y, T z, T *re, T *im)
bool ylmReal (int orderL, double dx, double dy, double dz, double *re, double *im)

Variables

constexpr double N3 [4]
constexpr double N4 [5]
constexpr double N6 [7]

Function Documentation

◆ avx512Kernels()

bool seams::ylm::avx512Kernels ( )

◆ evalUnit()

template<class T>
void seams::ylm::evalUnit ( int orderL,
T x,
T y,
T z,
T * re,
T * im )
inline

Definition at line 79 of file ylm_cartesian.hpp.

79 {
80 T wre[7];
81 T wim[7];
82 T zpow[7];
83 wre[0] = T(1);
84 wim[0] = T(0);
85 zpow[0] = T(1);
86 for (int m = 1; m <= orderL; ++m) {
87 const T prevRe = wre[m - 1];
88 const T prevIm = wim[m - 1];
89 wre[m] = prevRe * y - prevIm * x;
90 wim[m] = prevRe * x + prevIm * y;
91 zpow[m] = zpow[m - 1] * z;
92 }
93 const double *norm = (orderL == 3) ? N3 : N6;
94 for (int m = 0; m <= orderL; ++m) {
95 const T amp = T(norm[m]) * legendrePoly(orderL, m, zpow);
96 const int ineg = orderL - m;
97 const int ipos = orderL + m;
98 re[ineg] = amp * wre[m];
99 im[ineg] = -amp * wim[m];
100 const T signedAmp = (m & 1) ? -amp : amp;
101 re[ipos] = signedAmp * wre[m];
102 im[ipos] = signedAmp * wim[m];
103 }
104}
T legendrePoly(int orderL, int absM, const T *zpow)
constexpr double N3[4]
constexpr double N6[7]

◆ legendrePoly()

template<class T>
T seams::ylm::legendrePoly ( int orderL,
int absM,
const T * zpow )
inline

Definition at line 45 of file ylm_cartesian.hpp.

45 {
46 if (orderL == 3) {
47 switch (absM) {
48 case 0:
49 return T(5) * zpow[3] - T(3) * zpow[1];
50 case 1:
51 return T(5) * zpow[2] - T(1);
52 case 2:
53 return zpow[1];
54 default:
55 return T(1);
56 }
57 }
58 switch (absM) {
59 case 0:
60 return T(231) * zpow[6] - T(315) * zpow[4] + T(105) * zpow[2] - T(5);
61 case 1:
62 return T(33) * zpow[5] - T(30) * zpow[3] + T(5) * zpow[1];
63 case 2:
64 return T(33) * zpow[4] - T(18) * zpow[2] + T(1);
65 case 3:
66 return T(11) * zpow[3] - T(3) * zpow[1];
67 case 4:
68 return T(11) * zpow[2] - T(1);
69 case 5:
70 return zpow[1];
71 default:
72 return T(1);
73 }
74}

◆ ylm12AddBonds()

void seams::ylm::ylm12AddBonds ( const double * dx,
const double * dy,
const double * dz,
int n,
double * qlmInterleaved )

◆ ylmAdd8()

void seams::ylm::ylmAdd8 ( int orderL,
const double * dx,
const double * dy,
const double * dz,
double * accA,
double * accB )

◆ ylmBatch()

void seams::ylm::ylmBatch ( int orderL,
const double * dx,
const double * dy,
const double * dz,
int n,
double * re,
double * im )

◆ ylmLocalQl()

bool seams::ylm::ylmLocalQl ( int orderL,
const double * dx,
const double * dy,
const double * dz,
int nbonds,
const int * nUsed,
double prefactor,
double * ql )

◆ ylmReal()

bool seams::ylm::ylmReal ( int orderL,
double dx,
double dy,
double dz,
double * re,
double * im )
inline

Definition at line 108 of file ylm_cartesian.hpp.

109 {
110 const int nComp = 2 * orderL + 1;
111 const double r2 = dx * dx + dy * dy + dz * dz;
112 if (!(r2 > 0.0) || (orderL != 3 && orderL != 4 && orderL != 6)) {
113 for (int m = 0; m < nComp; ++m) {
114 re[m] = 0.0;
115 im[m] = 0.0;
116 }
117 return false;
118 }
119 // Even l: r^l is a power of r2. l = 3 keeps one square root.
120 double inv;
121 if (orderL == 6) {
122 const double r4 = r2 * r2;
123 inv = 1.0 / (r4 * r2);
124 } else if (orderL == 4) {
125 inv = 1.0 / (r2 * r2);
126 } else {
127 inv = 1.0 / (r2 * std::sqrt(r2));
128 }
129 const double *norm = (orderL == 3) ? N3 : (orderL == 4) ? N4 : N6;
130 solid::eval(orderL, dx, dy, dz, r2, inv, norm, re, im);
131 return true;
132}
void eval(int orderL, T x, T y, T z, T r2, T inv, const double *norm, T *re, T *im)
Definition solid_ylm.hpp:20
constexpr double N4[5]

◆ ylmSumRows4()

bool seams::ylm::ylmSumRows4 ( int orderL,
const double * dx,
const double * dy,
const double * dz,
double * rows,
int stride,
int nKeep )

Variable Documentation

◆ N3

double seams::ylm::N3[4]
inlineconstexpr
Initial value:
= {
0x1.7e21efc0768b0p-2,
0x1.4aefbf05f1305p-2,
0x1.05a0d7164496dp+0,
0x1.ab3cb8d675a30p-2
}

Definition at line 17 of file ylm_cartesian.hpp.

17 {
18 0x1.7e21efc0768b0p-2, // 0.25 * sqrt(7/pi)
19 0x1.4aefbf05f1305p-2, // 0.125 * sqrt(21/pi)
20 0x1.05a0d7164496dp+0, // 0.25 * sqrt(105/(2 pi))
21 0x1.ab3cb8d675a30p-2 // 0.125 * sqrt(35/pi)
22};

◆ N4

double seams::ylm::N4[5]
inlineconstexpr
Initial value:
= {
0x1.b14c2f863e924p-4,
0x1.e471027d29b68p-2,
0x1.568d44c02929cp-2,
0x1.406d8aa0d83a4p+0,
0x1.c5274a45d91d8p-2
}

Definition at line 24 of file ylm_cartesian.hpp.

24 {
25 0x1.b14c2f863e924p-4, // 0.1875 * sqrt(1/pi)
26 0x1.e471027d29b68p-2, // 0.375 * sqrt(5/pi)
27 0x1.568d44c02929cp-2, // 0.375 * sqrt(5/(2 pi))
28 0x1.406d8aa0d83a4p+0, // 0.375 * sqrt(35/pi)
29 0x1.c5274a45d91d8p-2 // 0.1875 * sqrt(35/(2 pi))
30};

◆ N6

double seams::ylm::N6[7]
inlineconstexpr
Initial value:
= {
0x1.046123cc5b3b1p-4,
0x1.a5dce8e510806p-2,
0x1.4d830dc3746c6p-2,
0x1.4d830dc3746c6p-1,
0x1.6d58113f224e2p-2,
0x1.ac67615af3632p+0,
0x1.eead9a142c943p-2
}

Definition at line 32 of file ylm_cartesian.hpp.

32 {
33 0x1.046123cc5b3b1p-4, // 0.03125 * sqrt(13/pi)
34 0x1.a5dce8e510806p-2, // 0.0625 * sqrt(273/(2 pi))
35 0x1.4d830dc3746c6p-2, // 0.015625 * sqrt(1365/pi)
36 0x1.4d830dc3746c6p-1, // 0.03125 * sqrt(1365/pi)
37 0x1.6d58113f224e2p-2, // 0.09375 * sqrt(91/(2 pi))
38 0x1.ac67615af3632p+0, // 0.09375 * sqrt(1001/pi)
39 0x1.eead9a142c943p-2 // 0.015625 * sqrt(3003/pi)
40};