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

Functions

void minImage (double &dx, double &dy, double &dz, double bx, double by, double bz)
double normLM (int orderL, int absM)
double legendreAmp (int orderL, int absM, const double *s, const double *c)
void ylmAllTrig (int orderL, double sinT, double cosT, double cphi, double sphi, double *out)
void ylmAll (int orderL, double theta, double phi, double *out)
void qlmAddBond (int orderL, double dx, double dy, double dz, double *qlmInterleaved, int row, int nComp, int &nUsed)
void qlmOneAtom (int iatom, int orderL, const double *xyz, const int *offsets, const int *cols, double bx, double by, double bz, double *qlmInterleaved)
void qlmOneAtomDr (int iatom, int orderL, const double *dr, const int *offsets, const int *cols, double *qlmInterleaved)
void qlOneAtom (int iatom, int orderL, const double *qlmInterleaved, const int *offsets, const int *cols, double *ql, double *qlBar)

Function Documentation

◆ legendreAmp()

double seams::steinhardt::legendreAmp ( int orderL,
int absM,
const double * s,
const double * c )
inline

Definition at line 124 of file steinhardt_device.hpp.

125 {
126 if (orderL == 3) {
127 switch (absM) {
128 case 0:
129 return 5.0 * c[3] - 3.0 * c[1];
130 case 1:
131 return s[1] * (5.0 * c[2] - 1.0);
132 case 2:
133 return s[2] * c[1];
134 case 3:
135 return s[3];
136 default:
137 return 0.0;
138 }
139 }
140 if (orderL == 4) {
141 switch (absM) {
142 case 0:
143 return 35.0 * c[4] - 30.0 * c[2] + 3.0;
144 case 1:
145 return s[1] * (7.0 * c[3] - 3.0 * c[1]);
146 case 2:
147 return s[2] * (7.0 * c[2] - 1.0);
148 case 3:
149 return s[3] * c[1];
150 case 4:
151 return s[4];
152 default:
153 return 0.0;
154 }
155 }
156 if (orderL == 6) {
157 switch (absM) {
158 case 0:
159 return 231.0 * c[6] - 315.0 * c[4] + 105.0 * c[2] - 5.0;
160 case 1:
161 return s[1] * (33.0 * c[5] - 30.0 * c[3] + 5.0 * c[1]);
162 case 2:
163 return s[2] * (33.0 * c[4] - 18.0 * c[2] + 1.0);
164 case 3:
165 return s[3] * (11.0 * c[3] - 3.0 * c[1]);
166 case 4:
167 return s[4] * (11.0 * c[2] - 1.0);
168 case 5:
169 return s[5] * c[1];
170 case 6:
171 return s[6];
172 default:
173 return 0.0;
174 }
175 }
176 if (orderL == 8) {
177 switch (absM) {
178 case 0:
179 return (35.0 + c[2] * (-1260.0 + c[2] * (6930.0 + c[2] * (-12012.0 + c[2] * 6435.0)))) / 128.0;
180 case 1:
181 return s[1] * c[1] * (-315.0 + c[2] * (3465.0 + c[2] * (-9009.0 + c[2] * 6435.0))) / 16.0;
182 case 2:
183 return s[2] * (-315.0 + c[2] * (10395.0 + c[2] * (-45045.0 + c[2] * 45045.0))) / 16.0;
184 case 3:
185 return s[3] * c[1] * (10395.0 + c[2] * (-90090.0 + c[2] * 135135.0)) / 8.0;
186 case 4:
187 return s[4] * (10395.0 + c[2] * (-270270.0 + c[2] * 675675.0)) / 8.0;
188 case 5:
189 return s[5] * c[1] * (-135135.0 + c[2] * 675675.0) / 2.0;
190 case 6:
191 return s[6] * (-135135.0 + c[2] * 2027025.0) / 2.0;
192 case 7:
193 return s[7] * c[1] * 2027025.0;
194 case 8:
195 return s[8] * 2027025.0;
196 default:
197 return 0.0;
198 }
199 }
200 return 0.0;
201}

◆ minImage()

void seams::steinhardt::minImage ( double & dx,
double & dy,
double & dz,
double bx,
double by,
double bz )
inline

Definition at line 23 of file steinhardt_device.hpp.

24 {
25 if (dx < -0.5 * bx) {
26 dx += bx;
27 }
28 if (dx >= 0.5 * bx) {
29 dx -= bx;
30 }
31 if (dy < -0.5 * by) {
32 dy += by;
33 }
34 if (dy >= 0.5 * by) {
35 dy -= by;
36 }
37 if (dz < -0.5 * bz) {
38 dz += bz;
39 }
40 if (dz >= 0.5 * bz) {
41 dz -= bz;
42 }
43}

◆ normLM()

double seams::steinhardt::normLM ( int orderL,
int absM )
inline

Definition at line 45 of file steinhardt_device.hpp.

45 {
46 constexpr double pi = 3.14159265358979323846;
47 if (orderL == 3) {
48 switch (absM) {
49 case 0:
50 return 0.25 * std::sqrt(7.0 / pi);
51 case 1:
52 return 0.125 * std::sqrt(21.0 / pi);
53 case 2:
54 return 0.25 * std::sqrt(105.0 / (2.0 * pi));
55 case 3:
56 return 0.125 * std::sqrt(35.0 / pi);
57 default:
58 return 0.0;
59 }
60 }
61 if (orderL == 4) {
62 switch (absM) {
63 case 0:
64 return 0.1875 * std::sqrt(1.0 / pi);
65 case 1:
66 return 0.375 * std::sqrt(5.0 / pi);
67 case 2:
68 return 0.375 * std::sqrt(5.0 / (2.0 * pi));
69 case 3:
70 return 0.375 * std::sqrt(35.0 / pi);
71 case 4:
72 return 0.1875 * std::sqrt(35.0 / (2.0 * pi));
73 default:
74 return 0.0;
75 }
76 }
77 if (orderL == 6) {
78 switch (absM) {
79 case 0:
80 return 0.03125 * std::sqrt(13.0 / pi);
81 case 1:
82 return 0.0625 * std::sqrt(273.0 / (2.0 * pi));
83 case 2:
84 return 0.015625 * std::sqrt(1365.0 / pi);
85 case 3:
86 return 0.03125 * std::sqrt(1365.0 / pi);
87 case 4:
88 return 0.09375 * std::sqrt(91.0 / (2.0 * pi));
89 case 5:
90 return 0.09375 * std::sqrt(1001.0 / pi);
91 case 6:
92 return 0.015625 * std::sqrt(3003.0 / pi);
93 default:
94 return 0.0;
95 }
96 }
97 if (orderL == 8) {
98 switch (absM) {
99 case 0:
100 return std::sqrt(17.0 / (4.0 * pi));
101 case 1:
102 return std::sqrt(17.0 / (288.0 * pi));
103 case 2:
104 return std::sqrt(17.0 / (20160.0 * pi));
105 case 3:
106 return std::sqrt(17.0 / (1330560.0 * pi));
107 case 4:
108 return std::sqrt(17.0 / (79833600.0 * pi));
109 case 5:
110 return std::sqrt(17.0 / (4151347200.0 * pi));
111 case 6:
112 return std::sqrt(17.0 / (174356582400.0 * pi));
113 case 7:
114 return std::sqrt(17.0 / (5230697472000.0 * pi));
115 case 8:
116 return std::sqrt(17.0 / (83691159552000.0 * pi));
117 default:
118 return 0.0;
119 }
120 }
121 return 0.0;
122}

◆ qlmAddBond()

void seams::steinhardt::qlmAddBond ( int orderL,
double dx,
double dy,
double dz,
double * qlmInterleaved,
int row,
int nComp,
int & nUsed )
inline

Definition at line 254 of file steinhardt_device.hpp.

256 {
257 if (orderL == 3 || orderL == 4 || orderL == 6) {
258 double re[13];
259 double im[13];
260 if (!seams::ylm::ylmReal(orderL, dx, dy, dz, re, im)) {
261 return;
262 }
263 for (int m = 0; m < nComp; m++) {
264 qlmInterleaved[2 * (row + m)] += re[m];
265 qlmInterleaved[2 * (row + m) + 1] += im[m];
266 }
267 nUsed++;
268 return;
269 }
270 const double r2 = dx * dx + dy * dy + dz * dz;
271 if (r2 == 0.0) {
272 return;
273 }
274 const double r = std::sqrt(r2);
275 const double invr = 1.0 / r;
276 double cosT = dz * invr;
277 if (cosT > 1.0) {
278 cosT = 1.0;
279 } else if (cosT < -1.0) {
280 cosT = -1.0;
281 }
282 const double rho2 = dx * dx + dy * dy;
283 double sinT = 0.0;
284 double cphi = 1.0;
285 double sphi = 0.0;
286 if (rho2 != 0.0) {
287 const double rho = std::sqrt(rho2);
288 sinT = rho * invr;
289 const double invrho = 1.0 / rho;
290 cphi = dy * invrho;
291 sphi = dx * invrho;
292 }
293 double ylm[34];
294 ylmAllTrig(orderL, sinT, cosT, cphi, sphi, ylm);
295 for (int m = 0; m < nComp; m++) {
296 qlmInterleaved[2 * (row + m)] += ylm[2 * m];
297 qlmInterleaved[2 * (row + m) + 1] += ylm[2 * m + 1];
298 }
299 nUsed++;
300}
void ylmAllTrig(int orderL, double sinT, double cosT, double cphi, double sphi, double *out)
bool ylmReal(int orderL, double dx, double dy, double dz, double *re, double *im)

◆ qlmOneAtom()

void seams::steinhardt::qlmOneAtom ( int iatom,
int orderL,
const double * xyz,
const int * offsets,
const int * cols,
double bx,
double by,
double bz,
double * qlmInterleaved )
inline

Definition at line 304 of file steinhardt_device.hpp.

306 {
307 (void)bx;
308 (void)by;
309 (void)bz;
310 const int nComp = 2 * orderL + 1;
311 const int iOff = 3 * iatom;
312 const int row = iatom * nComp;
313 for (int m = 0; m < nComp; m++) {
314 qlmInterleaved[2 * (row + m)] = 0.0;
315 qlmInterleaved[2 * (row + m) + 1] = 0.0;
316 }
317 const int j0 = offsets[iatom];
318 const int j1 = offsets[iatom + 1];
319 int nUsed = 0;
320 for (int p = j0; p < j1; p++) {
321 const int jatom = cols[p];
322 const double dx = xyz[iOff] - xyz[3 * jatom];
323 const double dy = xyz[iOff + 1] - xyz[3 * jatom + 1];
324 const double dz = xyz[iOff + 2] - xyz[3 * jatom + 2];
325 qlmAddBond(orderL, dx, dy, dz, qlmInterleaved, row, nComp, nUsed);
326 }
327 if (nUsed == 0) {
328 return;
329 }
330 const double inv = 1.0 / static_cast<double>(nUsed);
331 for (int m = 0; m < nComp; m++) {
332 qlmInterleaved[2 * (row + m)] *= inv;
333 qlmInterleaved[2 * (row + m) + 1] *= inv;
334 }
335}
void qlmAddBond(int orderL, double dx, double dy, double dz, double *qlmInterleaved, int row, int nComp, int &nUsed)

◆ qlmOneAtomDr()

void seams::steinhardt::qlmOneAtomDr ( int iatom,
int orderL,
const double * dr,
const int * offsets,
const int * cols,
double * qlmInterleaved )
inline

Definition at line 339 of file steinhardt_device.hpp.

341 {
342 const int nComp = 2 * orderL + 1;
343 const int row = iatom * nComp;
344 for (int m = 0; m < nComp; m++) {
345 qlmInterleaved[2 * (row + m)] = 0.0;
346 qlmInterleaved[2 * (row + m) + 1] = 0.0;
347 }
348 const int j0 = offsets[iatom];
349 const int j1 = offsets[iatom + 1];
350 int nUsed = 0;
351 for (int p = j0; p < j1; p++) {
352 qlmAddBond(orderL, dr[3 * p], dr[3 * p + 1], dr[3 * p + 2],
353 qlmInterleaved, row, nComp, nUsed);
354 }
355 if (nUsed == 0) {
356 return;
357 }
358 const double inv = 1.0 / static_cast<double>(nUsed);
359 for (int m = 0; m < nComp; m++) {
360 qlmInterleaved[2 * (row + m)] *= inv;
361 qlmInterleaved[2 * (row + m) + 1] *= inv;
362 }
363}

◆ qlOneAtom()

void seams::steinhardt::qlOneAtom ( int iatom,
int orderL,
const double * qlmInterleaved,
const int * offsets,
const int * cols,
double * ql,
double * qlBar )
inline

Definition at line 365 of file steinhardt_device.hpp.

367 {
368 constexpr double pi = 3.14159265358979323846;
369 const int nComp = 2 * orderL + 1;
370 const double prefactor = 4.0 * pi / (2.0 * orderL + 1.0);
371 const int row = iatom * nComp;
372 double sumLocal = 0.0;
373 for (int m = 0; m < nComp; m++) {
374 const double re = qlmInterleaved[2 * (row + m)];
375 const double im = qlmInterleaved[2 * (row + m) + 1];
376 sumLocal += re * re + im * im;
377 }
378 ql[iatom] = std::sqrt(prefactor * sumLocal);
379
380 const int j0 = offsets[iatom];
381 const int j1 = offsets[iatom + 1];
382 if (j0 == j1) {
383 qlBar[iatom] = ql[iatom];
384 return;
385 }
386 double barRe[17];
387 double barIm[17];
388 for (int m = 0; m < nComp; m++) {
389 barRe[m] = qlmInterleaved[2 * (row + m)];
390 barIm[m] = qlmInterleaved[2 * (row + m) + 1];
391 }
392 int nContrib = 1;
393 for (int p = j0; p < j1; p++) {
394 const int jatom = cols[p];
395 const int jRow = jatom * nComp;
396 for (int m = 0; m < nComp; m++) {
397 barRe[m] += qlmInterleaved[2 * (jRow + m)];
398 barIm[m] += qlmInterleaved[2 * (jRow + m) + 1];
399 }
400 nContrib++;
401 }
402 const double inv = 1.0 / static_cast<double>(nContrib);
403 double sumBar = 0.0;
404 for (int m = 0; m < nComp; m++) {
405 const double re = barRe[m] * inv;
406 const double im = barIm[m] * inv;
407 sumBar += re * re + im * im;
408 }
409 qlBar[iatom] = std::sqrt(prefactor * sumBar);
410}

◆ ylmAll()

void seams::steinhardt::ylmAll ( int orderL,
double theta,
double phi,
double * out )
inline

Definition at line 246 of file steinhardt_device.hpp.

246 {
247 ylmAllTrig(orderL, std::sin(theta), std::cos(theta), std::cos(phi),
248 std::sin(phi), out);
249}

◆ ylmAllTrig()

void seams::steinhardt::ylmAllTrig ( int orderL,
double sinT,
double cosT,
double cphi,
double sphi,
double * out )
inline

Definition at line 207 of file steinhardt_device.hpp.

208 {
209 const int nComp = 2 * orderL + 1;
210 for (int k = 0; k < nComp; k++) {
211 out[2 * k] = 0.0;
212 out[2 * k + 1] = 0.0;
213 }
214
215 double s[9];
216 double c[9];
217 double pr[9];
218 double pi[9];
219 s[0] = 1.0;
220 c[0] = 1.0;
221 pr[0] = 1.0;
222 pi[0] = 0.0;
223 for (int k = 1; k <= orderL; k++) {
224 s[k] = s[k - 1] * sinT;
225 c[k] = c[k - 1] * cosT;
226 pr[k] = pr[k - 1] * cphi - pi[k - 1] * sphi;
227 pi[k] = pr[k - 1] * sphi + pi[k - 1] * cphi;
228 }
229
230 for (int absM = 0; absM <= orderL; absM++) {
231 const double amp = normLM(orderL, absM) * legendreAmp(orderL, absM, s, c);
232 // Y_{l,-m} = amp * conj(e^{i m phi})
233 const double nre = amp * pr[absM];
234 const double nim = -amp * pi[absM];
235 const int ineg = orderL - absM;
236 out[2 * ineg] = nre;
237 out[2 * ineg + 1] = nim;
238 // Y_{l,+m} = (-1)^m amp * e^{i m phi}
239 const double sign = (absM % 2 == 0) ? 1.0 : -1.0;
240 const int ipos = orderL + absM;
241 out[2 * ipos] = sign * amp * pr[absM];
242 out[2 * ipos + 1] = sign * amp * pi[absM];
243 }
244}
double legendreAmp(int orderL, int absM, const double *s, const double *c)
double normLM(int orderL, int absM)