Line data Source code
1 : /*----------------------------------------------------------------------------*/
2 : /* CP2K: A general program to perform molecular dynamics simulations */
3 : /* Copyright 2000-2023 CP2K developers group <https://cp2k.org> */
4 : /* */
5 : /* SPDX-License-Identifier: BSD-3-Clause */
6 : /*----------------------------------------------------------------------------*/
7 :
8 : #include "../common/grid_common.h"
9 : #include "../common/grid_constants.h"
10 : #include <stdbool.h>
11 : #include <stdio.h>
12 : #include <stdlib.h>
13 :
14 : #if defined(__CUDACC__) || defined(__HIPCC__)
15 : #define GRID_DEVICE __device__
16 : #else
17 : #define GRID_DEVICE
18 : #endif
19 :
20 : /*******************************************************************************
21 : * \brief Adds given value to matrix element cab[idx(b)][idx(a)].
22 : * This function has to be implemented by the importing compilation unit.
23 : * Without thread safety it's simply: cab[idx(b) * n + idx(a)] += value;
24 : * \author Ole Schuett
25 : ******************************************************************************/
26 : GRID_DEVICE static inline void prep_term(const orbital a, const orbital b,
27 : const double value, const int n,
28 : double *cab);
29 :
30 : /*******************************************************************************
31 : * \brief Implementation of function GRID_FUNC_AB, ie. identity transformation.
32 : * \author Ole Schuett
33 : ******************************************************************************/
34 971781639 : GRID_DEVICE static void prepare_pab_AB(const orbital a, const orbital b,
35 : const double pab_val, const int n,
36 : double *cab) {
37 :
38 : // simply copy pab to cab
39 971781639 : prep_term(a, b, pab_val, n, cab);
40 971781639 : }
41 :
42 : /*******************************************************************************
43 : * \brief Implementation of function GRID_FUNC_DADB.
44 : * \author Ole Schuett
45 : ******************************************************************************/
46 13668510 : GRID_DEVICE static void prepare_pab_DADB(const orbital a, const orbital b,
47 : const double zeta, const double zetb,
48 : const double pab_val, const int n,
49 : double *cab) {
50 :
51 : // creates cab such that mapping it with pgf_a pgf_b
52 : // is equivalent to mapping pab with 0.5 * (nabla pgf_a) . (nabla pgf_b)
53 : // (ddx pgf_a ) (ddx pgf_b) = (lax pgf_{a-1x} - 2*zeta*pgf_{a+1x})*(lbx
54 : // pgf_{b-1x} - 2*zetb*pgf_{b+1x})
55 :
56 54674040 : for (int i = 0; i < 3; i++) {
57 41005530 : prep_term(down(i, a), down(i, b), 0.5 * a.l[i] * b.l[i] * pab_val, n, cab);
58 41005530 : prep_term(down(i, a), up(i, b), -1.0 * a.l[i] * zetb * pab_val, n, cab);
59 41005530 : prep_term(up(i, a), down(i, b), -1.0 * zeta * b.l[i] * pab_val, n, cab);
60 41005530 : prep_term(up(i, a), up(i, b), 2.0 * zeta * zetb * pab_val, n, cab);
61 : }
62 13668510 : }
63 :
64 : /*******************************************************************************
65 : * \brief Implementation of function GRID_FUNC_ADBmDAB_{X,Y,Z}.
66 : * \author Ole Schuett
67 : ******************************************************************************/
68 1688853 : GRID_DEVICE static void prepare_pab_ADBmDAB(const int idir, const orbital a,
69 : const orbital b, const double zeta,
70 : const double zetb,
71 : const double pab_val, const int n,
72 : double *cab) {
73 :
74 : // creates cab such that mapping it with pgf_a pgf_b
75 : // is equivalent to mapping pab with
76 : // pgf_a (nabla_{idir} pgf_b) - (nabla_{idir} pgf_a) pgf_b
77 : // ( pgf_a ) (ddx pgf_b) - (ddx pgf_a)( pgf_b ) =
78 : // pgf_a *(lbx pgf_{b-1x} - 2*zetb*pgf_{b+1x}) -
79 : // (lax pgf_{a-1x} - 2*zeta*pgf_{a+1x}) pgf_b
80 :
81 1688853 : prep_term(a, down(idir, b), +b.l[idir] * pab_val, n, cab);
82 1688853 : prep_term(a, up(idir, b), -2.0 * zetb * pab_val, n, cab);
83 1688853 : prep_term(down(idir, a), b, -a.l[idir] * pab_val, n, cab);
84 1688853 : prep_term(up(idir, a), b, +2.0 * zeta * pab_val, n, cab);
85 1688853 : }
86 :
87 : /*******************************************************************************
88 : * \brief Implementation of function GRID_FUNC_ARDBmDARB_{X,Y,Z}{X,Y,Z}.
89 : * \author Ole Schuett
90 : ******************************************************************************/
91 : GRID_DEVICE static void
92 2542110 : prepare_pab_ARDBmDARB(const int idir, const int ir, const orbital a,
93 : const orbital b, const double zeta, const double zetb,
94 : const double pab_val, const int n, double *cab) {
95 :
96 : // creates cab such that mapping it with pgf_a pgf_b
97 : // is equivalent to mapping pab with
98 : // pgf_a (r-Rb)_{ir} (nabla_{idir} pgf_b) - (nabla_{idir} pgf_a) (r-Rb)_{ir}
99 : // pgf_b ( pgf_a )(r-Rb)_{ir} (ddx pgf_b) - (ddx pgf_a) (r-Rb)_{ir} ( pgf_b )
100 : // =
101 : // pgf_a *(lbx pgf_{b-1x+1ir} - 2*zetb*pgf_{b+1x+1ir})
102 : // -
103 : // (lax pgf_{a-1x} - 2*zeta*pgf_{a+1x}) pgf_{b+1ir}
104 :
105 2542110 : prep_term(a, down(idir, up(ir, b)), b.l[idir] * pab_val, n, cab);
106 2542110 : prep_term(a, up(idir, up(ir, b)), -2.0 * zetb * pab_val, n, cab);
107 2542110 : prep_term(down(idir, a), up(ir, b), -a.l[idir] * pab_val, n, cab);
108 2542110 : prep_term(up(idir, a), up(ir, b), +2.0 * zeta * pab_val, n, cab);
109 2542110 : }
110 :
111 : /*******************************************************************************
112 : * \brief Implementation of function GRID_FUNC_DABpADB_{X,Y,Z}.
113 : * \author Ole Schuett
114 : ******************************************************************************/
115 3545034 : GRID_DEVICE static void prepare_pab_DABpADB(const int idir, const orbital a,
116 : const orbital b, const double zeta,
117 : const double zetb,
118 : const double pab_val, const int n,
119 : double *cab) {
120 :
121 : // creates cab such that mapping it with pgf_a pgf_b
122 : // is equivalent to mapping pab with
123 : // pgf_a (nabla_{idir} pgf_b) + (nabla_{idir} pgf_a) pgf_b
124 : // ( pgf_a ) (ddx pgf_b) + (ddx pgf_a)( pgf_b ) =
125 : // pgf_a *(lbx pgf_{b-1x} + 2*zetb*pgf_{b+1x}) +
126 : // (lax pgf_{a-1x} + 2*zeta*pgf_{a+1x}) pgf_b
127 :
128 3545034 : prep_term(a, down(idir, b), b.l[idir] * pab_val, n, cab);
129 3545034 : prep_term(a, up(idir, b), -2.0 * zetb * pab_val, n, cab);
130 3545034 : prep_term(down(idir, a), b, a.l[idir] * pab_val, n, cab);
131 3545034 : prep_term(up(idir, a), b, -2.0 * zeta * pab_val, n, cab);
132 3545034 : }
133 :
134 : /*******************************************************************************
135 : * \brief Implementation of function GRID_FUNC_DAB_{X,Y,Z}.
136 : * This function takes the derivates with respect to nuclear positions
137 : * which results in a change of signs compared to prepare_pab_DABpADB.
138 : * Only the derivative with respect to the primitive on the left.
139 : * \author Edward Ditler
140 : ******************************************************************************/
141 14661 : GRID_DEVICE static void prepare_pab_DAB(const int idir, const orbital a,
142 : const orbital b, const double zeta,
143 : const double pab_val, const int n,
144 : double *cab) {
145 :
146 : // creates cab such that mapping it with pgf_a pgf_b
147 : // is equivalent to mapping pab with (nabla_{idir} pgf_a) pgf_b
148 : // (ddX pgf_a)( pgf_b ) =
149 : // (-lax pgf_{a-1x} - 2*zeta*pgf_{a+1x}) pgf_b
150 :
151 14661 : prep_term(down(idir, a), b, -a.l[idir] * pab_val, n, cab);
152 14661 : prep_term(up(idir, a), b, +2.0 * zeta * pab_val, n, cab);
153 14661 : }
154 :
155 : /*******************************************************************************
156 : * \brief Implementation of function GRID_FUNC_ADB_{X,Y,Z}.
157 : * This function takes the derivates with respect to nuclear positions
158 : * which results in a change of signs compared to prepare_pab_DABpADB.
159 : * Only the derivative with respect to the primitive on the right.
160 : * \author Edward Ditler
161 : ******************************************************************************/
162 14661 : GRID_DEVICE static void prepare_pab_ADB(const int idir, const orbital a,
163 : const orbital b, const double zetb,
164 : const double pab_val, const int n,
165 : double *cab) {
166 :
167 : // creates cab such that mapping it with pgf_a pgf_b
168 : // is equivalent to mapping pab with
169 : // pgf_a (nabla_{idir} pgf_b) + (nabla_{idir} pgf_a) pgf_b
170 : // ( pgf_a ) (ddX pgf_b) =
171 : // pgf_a *(-lbx pgf_{b-1x} - 2*zetb*pgf_{b+1x})
172 :
173 14661 : prep_term(a, down(idir, b), -b.l[idir] * pab_val, n, cab);
174 14661 : prep_term(a, up(idir, b), +2.0 * zetb * pab_val, n, cab);
175 14661 : }
176 :
177 : /*******************************************************************************
178 : * \brief Implementation of function GRID_FUNC_CORE_{X,Y,Z}.
179 : * This function takes the derivates with respect to nuclear positions.
180 : * \author Edward Ditler
181 : ******************************************************************************/
182 54 : GRID_DEVICE static void prepare_pab_core(const int idir, const orbital a,
183 : const orbital b, const double zeta,
184 : const double pab_val, const int n,
185 : double *cab) {
186 :
187 : // creates cab such that mapping it with pgf_a pgf_b
188 : // is equivalent to mapping pab with (nabla_{idir} pgf_a) pgf_b
189 : // (ddX pgf_a)( pgf_b ) = 2*zeta*pgf_{a+1x}) pgf_b
190 :
191 54 : prep_term(a, down(idir, b), 0.0, n, cab);
192 54 : prep_term(a, up(idir, b), 0.0, n, cab);
193 54 : prep_term(down(idir, a), b, 0.0, n, cab);
194 54 : prep_term(up(idir, a), b, +2.0 * zeta * pab_val, n, cab);
195 54 : }
196 :
197 : /*******************************************************************************
198 : * \brief Implementation of function GRID_FUNC_{DX,DY,DZ}.
199 : * \author Ole Schuett
200 : ******************************************************************************/
201 2071464 : GRID_DEVICE static void prepare_pab_Di(const int ider, const orbital a,
202 : const orbital b, const double zeta,
203 : const double zetb, const double pab_val,
204 : const int n, double *cab) {
205 :
206 : // creates cab such that mapping it with pgf_a pgf_b
207 : // is equivalent to mapping pab with
208 : // d_{ider1} pgf_a d_{ider1} pgf_b
209 : // dx pgf_a dx pgf_b =
210 : // (lax pgf_{a-1x})*(lbx pgf_{b-1x}) - 2*zetb*lax*pgf_{a-1x}*pgf_{b+1x}
211 : // -
212 : // lbx pgf_{b-1x}*2*zeta*pgf_{a+1x}+ 4*zeta*zetab*pgf_{a+1x}pgf_{b+1x}
213 :
214 2071464 : prep_term(down(ider, a), down(ider, b), a.l[ider] * b.l[ider] * pab_val, n,
215 : cab);
216 2071464 : prep_term(down(ider, a), up(ider, b), -2.0 * a.l[ider] * zetb * pab_val, n,
217 : cab);
218 2071464 : prep_term(up(ider, a), down(ider, b), -2.0 * zeta * b.l[ider] * pab_val, n,
219 : cab);
220 2071464 : prep_term(up(ider, a), up(ider, b), +4.0 * zeta * zetb * pab_val, n, cab);
221 2071464 : }
222 :
223 : /*******************************************************************************
224 : * \brief Helper for grid_prepare_pab_DiDj.
225 : * \author Ole Schuett
226 : ******************************************************************************/
227 0 : GRID_DEVICE static void oneterm_dijdij(const int idir, const double func_a,
228 : const orbital a, const orbital b,
229 : const double zetb, const int n,
230 : double *cab) {
231 :
232 0 : int i1, i2;
233 0 : if (idir == 0) {
234 : i1 = 0;
235 : i2 = 1;
236 : } else if (idir == 1) {
237 : i1 = 1;
238 : i2 = 2;
239 : } else if (idir == 2) {
240 : i1 = 2;
241 : i2 = 0;
242 : } else {
243 : return; // error
244 : }
245 :
246 0 : prep_term(a, down(i1, down(i2, b)), b.l[i1] * b.l[i2] * func_a, n, cab);
247 0 : prep_term(a, up(i1, down(i2, b)), -2.0 * zetb * b.l[i2] * func_a, n, cab);
248 0 : prep_term(a, down(i1, up(i2, b)), -2.0 * zetb * b.l[i1] * func_a, n, cab);
249 0 : prep_term(a, up(i1, up(i2, b)), +4.0 * zetb * zetb * func_a, n, cab);
250 : }
251 :
252 : /*******************************************************************************
253 : * \brief Implementation of function GRID_FUNC_{DXDY,DYDZ,DZDX}
254 : * \author Ole Schuett
255 : ******************************************************************************/
256 0 : GRID_DEVICE static void prepare_pab_DiDj(const int ider1, const int ider2,
257 : const orbital a, const orbital b,
258 : const double zeta, const double zetb,
259 : const double pab_val, const int n,
260 : double *cab) {
261 :
262 : // creates cab such that mapping it with pgf_a pgf_b
263 : // is equivalent to mapping pab with
264 : // d_{ider1} pgf_a d_{ider1} pgf_b
265 :
266 0 : const double func_a1 = a.l[ider1] * a.l[ider2] * pab_val;
267 0 : oneterm_dijdij(ider1, func_a1, down(ider1, down(ider2, a)), b, zetb, n, cab);
268 :
269 0 : const double func_a2 = -2.0 * zeta * a.l[ider2] * pab_val;
270 0 : oneterm_dijdij(ider1, func_a2, up(ider1, down(ider2, a)), b, zetb, n, cab);
271 :
272 0 : const double func_a3 = -2.0 * zeta * a.l[ider1] * pab_val;
273 0 : oneterm_dijdij(ider1, func_a3, down(ider1, up(ider2, a)), b, zetb, n, cab);
274 :
275 0 : const double func_a4 = 4.0 * zeta * zeta * pab_val;
276 0 : oneterm_dijdij(ider1, func_a4, up(ider1, up(ider2, a)), b, zetb, n, cab);
277 0 : }
278 :
279 : /*******************************************************************************
280 : * \brief Helper for grid_prepare_pab_Di2.
281 : * \author Ole Schuett
282 : ******************************************************************************/
283 0 : GRID_DEVICE static void oneterm_diidii(const int idir, const double func_a,
284 : const orbital a, const orbital b,
285 : const double zetb, const int n,
286 : double *cab) {
287 :
288 0 : prep_term(a, down(idir, down(idir, b)), b.l[idir] * (b.l[idir] - 1) * func_a,
289 : n, cab);
290 0 : prep_term(a, b, -2.0 * zetb * (2 * b.l[idir] + 1) * func_a, n, cab);
291 0 : prep_term(a, up(idir, up(idir, b)), +4.0 * zetb * zetb * func_a, n, cab);
292 0 : }
293 :
294 : /*******************************************************************************
295 : * \brief Implementation of function GRID_FUNC_{DXDX,DYDY,DZDZ}
296 : * \author Ole Schuett
297 : ******************************************************************************/
298 0 : GRID_DEVICE static void prepare_pab_Di2(const int ider, const orbital a,
299 : const orbital b, const double zeta,
300 : const double zetb, const double pab_val,
301 : const int n, double *cab) {
302 :
303 : // creates cab such that mapping it with pgf_a pgf_b
304 : // is equivalent to mapping pab with
305 : // dd_{ider1} pgf_a dd_{ider1} pgf_b
306 :
307 0 : const double func_a1 = a.l[ider] * (a.l[ider] - 1) * pab_val;
308 0 : oneterm_diidii(ider, func_a1, down(ider, down(ider, a)), b, zetb, n, cab);
309 :
310 0 : const double func_a2 = -2.0 * zeta * (2 * a.l[ider] + 1) * pab_val;
311 0 : oneterm_diidii(ider, func_a2, a, b, zetb, n, cab);
312 :
313 0 : const double func_a3 = 4.0 * zeta * zeta * pab_val;
314 0 : oneterm_diidii(ider, func_a3, up(ider, up(ider, a)), b, zetb, n, cab);
315 0 : }
316 :
317 : /*******************************************************************************
318 : * \brief Transforms a given element of the density matrix according to func.
319 : * \param func Transformation function to apply, one of GRID_FUNC_*.
320 : * \param {a,b} Orbital angular momenta.
321 : * \param zet_{a,b} Gaussian exponents.
322 : * \param pab_val Input matrix element of pab.
323 : * \param n Leading dimensions of output matrix cab.
324 : * \param cab Output matrix.
325 : * \author Ole Schuett
326 : ******************************************************************************/
327 995326986 : GRID_DEVICE static void prepare_pab(const enum grid_func func, const orbital a,
328 : const orbital b, const double zeta,
329 : const double zetb, const double pab_val,
330 : const int n, double *cab) {
331 :
332 : // This switch statment will be in an inner loop but only with few iterations.
333 995326986 : switch (func) {
334 971781639 : case GRID_FUNC_AB:
335 971781639 : prepare_pab_AB(a, b, pab_val, n, cab);
336 971781639 : break;
337 13668510 : case GRID_FUNC_DADB:
338 13668510 : prepare_pab_DADB(a, b, zeta, zetb, pab_val, n, cab);
339 13668510 : break;
340 562951 : case GRID_FUNC_ADBmDAB_X:
341 562951 : prepare_pab_ADBmDAB(0, a, b, zeta, zetb, pab_val, n, cab);
342 562951 : break;
343 562951 : case GRID_FUNC_ADBmDAB_Y:
344 562951 : prepare_pab_ADBmDAB(1, a, b, zeta, zetb, pab_val, n, cab);
345 562951 : break;
346 562951 : case GRID_FUNC_ADBmDAB_Z:
347 562951 : prepare_pab_ADBmDAB(2, a, b, zeta, zetb, pab_val, n, cab);
348 562951 : break;
349 275958 : case GRID_FUNC_ARDBmDARB_XX:
350 275958 : prepare_pab_ARDBmDARB(0, 0, a, b, zeta, zetb, pab_val, n, cab);
351 275958 : break;
352 285706 : case GRID_FUNC_ARDBmDARB_XY:
353 285706 : prepare_pab_ARDBmDARB(0, 1, a, b, zeta, zetb, pab_val, n, cab);
354 285706 : break;
355 285706 : case GRID_FUNC_ARDBmDARB_XZ:
356 285706 : prepare_pab_ARDBmDARB(0, 2, a, b, zeta, zetb, pab_val, n, cab);
357 285706 : break;
358 285706 : case GRID_FUNC_ARDBmDARB_YX:
359 285706 : prepare_pab_ARDBmDARB(1, 0, a, b, zeta, zetb, pab_val, n, cab);
360 285706 : break;
361 275958 : case GRID_FUNC_ARDBmDARB_YY:
362 275958 : prepare_pab_ARDBmDARB(1, 1, a, b, zeta, zetb, pab_val, n, cab);
363 275958 : break;
364 285706 : case GRID_FUNC_ARDBmDARB_YZ:
365 285706 : prepare_pab_ARDBmDARB(1, 2, a, b, zeta, zetb, pab_val, n, cab);
366 285706 : break;
367 285706 : case GRID_FUNC_ARDBmDARB_ZX:
368 285706 : prepare_pab_ARDBmDARB(2, 0, a, b, zeta, zetb, pab_val, n, cab);
369 285706 : break;
370 285706 : case GRID_FUNC_ARDBmDARB_ZY:
371 285706 : prepare_pab_ARDBmDARB(2, 1, a, b, zeta, zetb, pab_val, n, cab);
372 285706 : break;
373 275958 : case GRID_FUNC_ARDBmDARB_ZZ:
374 275958 : prepare_pab_ARDBmDARB(2, 2, a, b, zeta, zetb, pab_val, n, cab);
375 275958 : break;
376 1181678 : case GRID_FUNC_DABpADB_X:
377 1181678 : prepare_pab_DABpADB(0, a, b, zeta, zetb, pab_val, n, cab);
378 1181678 : break;
379 1181678 : case GRID_FUNC_DABpADB_Y:
380 1181678 : prepare_pab_DABpADB(1, a, b, zeta, zetb, pab_val, n, cab);
381 1181678 : break;
382 1181678 : case GRID_FUNC_DABpADB_Z:
383 1181678 : prepare_pab_DABpADB(2, a, b, zeta, zetb, pab_val, n, cab);
384 1181678 : break;
385 4887 : case GRID_FUNC_DAB_X:
386 4887 : prepare_pab_DAB(0, a, b, zeta, pab_val, n, cab);
387 4887 : break;
388 4887 : case GRID_FUNC_DAB_Y:
389 4887 : prepare_pab_DAB(1, a, b, zeta, pab_val, n, cab);
390 4887 : break;
391 4887 : case GRID_FUNC_DAB_Z:
392 4887 : prepare_pab_DAB(2, a, b, zeta, pab_val, n, cab);
393 4887 : break;
394 4887 : case GRID_FUNC_ADB_X:
395 4887 : prepare_pab_ADB(0, a, b, zetb, pab_val, n, cab);
396 4887 : break;
397 4887 : case GRID_FUNC_ADB_Y:
398 4887 : prepare_pab_ADB(1, a, b, zetb, pab_val, n, cab);
399 4887 : break;
400 4887 : case GRID_FUNC_ADB_Z:
401 4887 : prepare_pab_ADB(2, a, b, zetb, pab_val, n, cab);
402 4887 : break;
403 18 : case GRID_FUNC_CORE_X:
404 18 : prepare_pab_core(0, a, b, zeta, pab_val, n, cab);
405 18 : break;
406 18 : case GRID_FUNC_CORE_Y:
407 18 : prepare_pab_core(1, a, b, zeta, pab_val, n, cab);
408 18 : break;
409 18 : case GRID_FUNC_CORE_Z:
410 18 : prepare_pab_core(2, a, b, zeta, pab_val, n, cab);
411 18 : break;
412 0 : case GRID_FUNC_DX:
413 0 : prepare_pab_Di(0, a, b, zeta, zetb, pab_val, n, cab);
414 0 : break;
415 0 : case GRID_FUNC_DY:
416 0 : prepare_pab_Di(1, a, b, zeta, zetb, pab_val, n, cab);
417 0 : break;
418 2071464 : case GRID_FUNC_DZ:
419 2071464 : prepare_pab_Di(2, a, b, zeta, zetb, pab_val, n, cab);
420 2071464 : break;
421 0 : case GRID_FUNC_DXDY:
422 0 : prepare_pab_DiDj(0, 1, a, b, zeta, zetb, pab_val, n, cab);
423 0 : break;
424 0 : case GRID_FUNC_DYDZ:
425 0 : prepare_pab_DiDj(1, 2, a, b, zeta, zetb, pab_val, n, cab);
426 0 : break;
427 0 : case GRID_FUNC_DZDX:
428 0 : prepare_pab_DiDj(2, 0, a, b, zeta, zetb, pab_val, n, cab);
429 0 : break;
430 0 : case GRID_FUNC_DXDX:
431 0 : prepare_pab_Di2(0, a, b, zeta, zetb, pab_val, n, cab);
432 0 : break;
433 0 : case GRID_FUNC_DYDY:
434 0 : prepare_pab_Di2(1, a, b, zeta, zetb, pab_val, n, cab);
435 0 : break;
436 0 : case GRID_FUNC_DZDZ:
437 0 : prepare_pab_Di2(2, a, b, zeta, zetb, pab_val, n, cab);
438 0 : break;
439 : default:
440 : break; // Error: Unknown ga_gb_function - do nothing.
441 : }
442 995326986 : }
443 :
444 : /*******************************************************************************
445 : * \brief Differences in angular momentum.
446 : * \author Ole Schuett
447 : ******************************************************************************/
448 : typedef struct {
449 : int la_max_diff;
450 : int la_min_diff;
451 : int lb_max_diff;
452 : int lb_min_diff;
453 : } prepare_ldiffs;
454 :
455 : /*******************************************************************************
456 : * \brief Returns difference in angular momentum range for given func.
457 : * \author Ole Schuett
458 : ******************************************************************************/
459 84918217 : static prepare_ldiffs prepare_get_ldiffs(const enum grid_func func) {
460 84918217 : prepare_ldiffs ldiffs;
461 :
462 84918217 : switch (func) {
463 : case GRID_FUNC_AB:
464 : ldiffs.la_max_diff = 0;
465 : ldiffs.la_min_diff = 0;
466 : ldiffs.lb_max_diff = 0;
467 : ldiffs.lb_min_diff = 0;
468 : break;
469 2409252 : case GRID_FUNC_DADB:
470 : case GRID_FUNC_ADBmDAB_X:
471 : case GRID_FUNC_ADBmDAB_Y:
472 : case GRID_FUNC_ADBmDAB_Z:
473 : case GRID_FUNC_DABpADB_X:
474 : case GRID_FUNC_DABpADB_Y:
475 : case GRID_FUNC_DABpADB_Z:
476 : case GRID_FUNC_DAB_X:
477 : case GRID_FUNC_DAB_Y:
478 : case GRID_FUNC_DAB_Z:
479 : case GRID_FUNC_ADB_X:
480 : case GRID_FUNC_ADB_Y:
481 : case GRID_FUNC_ADB_Z:
482 : case GRID_FUNC_CORE_X:
483 : case GRID_FUNC_CORE_Y:
484 : case GRID_FUNC_CORE_Z:
485 2409252 : ldiffs.la_max_diff = +1;
486 2409252 : ldiffs.la_min_diff = -1;
487 2409252 : ldiffs.lb_max_diff = +1;
488 2409252 : ldiffs.lb_min_diff = -1;
489 2409252 : break;
490 286668 : case GRID_FUNC_ARDBmDARB_XX:
491 : case GRID_FUNC_ARDBmDARB_XY:
492 : case GRID_FUNC_ARDBmDARB_XZ:
493 : case GRID_FUNC_ARDBmDARB_YX:
494 : case GRID_FUNC_ARDBmDARB_YY:
495 : case GRID_FUNC_ARDBmDARB_YZ:
496 : case GRID_FUNC_ARDBmDARB_ZX:
497 : case GRID_FUNC_ARDBmDARB_ZY:
498 : case GRID_FUNC_ARDBmDARB_ZZ:
499 286668 : ldiffs.la_max_diff = +1;
500 286668 : ldiffs.la_min_diff = -1;
501 286668 : ldiffs.lb_max_diff = +2; // this is legit
502 286668 : ldiffs.lb_min_diff = -1;
503 286668 : break;
504 38464 : case GRID_FUNC_DX:
505 : case GRID_FUNC_DY:
506 : case GRID_FUNC_DZ:
507 38464 : ldiffs.la_max_diff = +1;
508 38464 : ldiffs.la_min_diff = -1;
509 38464 : ldiffs.lb_max_diff = +1;
510 38464 : ldiffs.lb_min_diff = -1;
511 38464 : break;
512 0 : case GRID_FUNC_DXDY:
513 : case GRID_FUNC_DYDZ:
514 : case GRID_FUNC_DZDX:
515 : case GRID_FUNC_DXDX:
516 : case GRID_FUNC_DYDY:
517 : case GRID_FUNC_DZDZ:
518 0 : ldiffs.la_max_diff = +2;
519 0 : ldiffs.la_min_diff = -2;
520 0 : ldiffs.lb_max_diff = +2;
521 0 : ldiffs.lb_min_diff = -2;
522 0 : break;
523 0 : default:
524 0 : fprintf(stderr, "Error: Unknown ga_gb_function %i.\n", func);
525 0 : abort();
526 : }
527 :
528 84918217 : return ldiffs;
529 : }
530 :
531 : // EOF
|
