ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

small programming style upgrade, apply clang-format, silence compiler warnings

Browse Source
This commit is contained in:
Axel Kohlmeyer
2022-05-06 16:44:13 -04:00
parent 6432660bc9
commit 051c243cfc
3 changed files with 59 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/KOKKOS/compute_orientorder_atom_kokkos.cpp
View File

@ -38,16 +38,15 @@
using namespace LAMMPS_NS;
using namespace MathConst;
using namespace MathSpecial;
using namespace std;
using MathSpecial::factorial;
#ifdef DBL_EPSILON
#define MY_EPSILON (10.0*DBL_EPSILON)
static constexpr double MY_EPSILON = (10.0 * DBL_EPSILON);
#else
#define MY_EPSILON (10.0*2.220446049250313e-16)
static constexpr double MY_EPSILON = (10.0 * 2.220446049250313e-16);
#endif
#define QEPSILON 1.0e-6
static constexpr double QEPSILON = 1.0e-6;
/* ---------------------------------------------------------------------- */

59
src/compute_orientorder_atom.cpp
View File

@ -39,23 +39,22 @@
using namespace LAMMPS_NS;
using namespace MathConst;
using namespace MathSpecial;
using MathSpecial::factorial;
#ifdef DBL_EPSILON
#define MY_EPSILON (10.0 * DBL_EPSILON)
static constexpr double MY_EPSILON = (10.0 * DBL_EPSILON);
#else
#define MY_EPSILON (10.0 * 2.220446049250313e-16)
static constexpr double MY_EPSILON = (10.0 * 2.220446049250313e-16);
#endif
#define QEPSILON 1.0e-6
static constexpr double QEPSILON = 1.0e-6;
/* ---------------------------------------------------------------------- */
ComputeOrientOrderAtom::ComputeOrientOrderAtom(LAMMPS *lmp, int narg, char **arg) :
Compute(lmp, narg, arg),
qlist(nullptr), distsq(nullptr), nearest(nullptr), rlist(nullptr),
qnarray(nullptr), qnm_r(nullptr), qnm_i(nullptr), w3jlist(nullptr),
qnormfac(nullptr),qnormfac2(nullptr)
Compute(lmp, narg, arg), qlist(nullptr), qnormfac(nullptr), qnormfac2(nullptr), distsq(nullptr),
nearest(nullptr), rlist(nullptr), qnarray(nullptr), qnm_r(nullptr), qnm_i(nullptr),
w3jlist(nullptr)
{
if (narg < 3) error->all(FLERR, "Illegal compute orientorder/atom command");
@ -535,12 +534,13 @@ void ComputeOrientOrderAtom::calc_boop(double **rlist, int ncount, double qn[],
// such symmetry (invariance) group.
// m1 <= 0, and Qlm[-m] = (-1)^m * conjg(Qlm[m])
const double Q1Q2_r = (qnm_r[il][-m1] * qnm_r[il][m2] + qnm_i[il][-m1] * qnm_i[il][m2]) * sgn;
const double Q1Q2_i = (qnm_r[il][-m1] * qnm_i[il][m2] - qnm_i[il][-m1] * qnm_r[il][m2]) * sgn;
const double Q1Q2_r =
(qnm_r[il][-m1] * qnm_r[il][m2] + qnm_i[il][-m1] * qnm_i[il][m2]) * sgn;
const double Q1Q2_i =
(qnm_r[il][-m1] * qnm_i[il][m2] - qnm_i[il][-m1] * qnm_r[il][m2]) * sgn;
const double Q1Q2Q3 = Q1Q2_r * qnm_r[il][m3] - Q1Q2_i * qnm_i[il][m3];
const double c = w3jlist[widx_count++];
wlsum += Q1Q2Q3 * c;
}
}
qn[jj++] = wlsum / qnormfac2[il];
@ -648,9 +648,7 @@ void ComputeOrientOrderAtom::init_wigner3j()
const int l = qlist[il];
for (int m1 = -l; m1 <= 0; m1++) {
for (int m2 = 0; m2<=((-m1)>>1); m2++) {
widx_count++;
}
for (int m2 = 0; m2 <= ((-m1) >> 1); m2++) { widx_count++; }
}
}
widx_max = widx_count;
@ -675,12 +673,14 @@ void ComputeOrientOrderAtom::init_wigner3j()
// Determine number of elements in symmetry group of (m1,m2,m3)
// Concise determination exploiting (m1,m2,m3) loop structure.
int pfac;
if (m1 == 0) pfac = 1; // m1 = m2 = m3 = 0
if (m1 == 0)
pfac = 1; // m1 = m2 = m3 = 0
else if (m2 == 0 || m2 == m3) {
// reduced group when only 3 permutations, or sign inversion
// is equivalent to permutation
pfac = 6;
} else pfac = 12; // 6 permutations * 2 signs
} else
pfac = 12; // 6 permutations * 2 signs
w3jlist[widx_count] = w3j(l, m1, m2, m3) * pfac;
widx_count++;
@ -691,26 +691,29 @@ void ComputeOrientOrderAtom::init_wigner3j()
/* ---------------------------------------------------------------------- */
double ComputeOrientOrderAtom::triangle_coeff(const int a, const int b, const int c) {
return factorial(a+b-c)*factorial(a-b+c)*factorial(-a+b+c) / factorial(a+b+c+1);
double ComputeOrientOrderAtom::triangle_coeff(const int a, const int b, const int c)
{
return factorial(a + b - c) * factorial(a - b + c) * factorial(-a + b + c) /
factorial(a + b + c + 1);
}
/* ---------------------------------------------------------------------- */
double ComputeOrientOrderAtom::w3j(const int lmax, const int j1, const int j2, const int j3) {
double ComputeOrientOrderAtom::w3j(const int lmax, const int j1, const int j2, const int j3)
{
const int a = lmax, b = lmax, c = lmax;
const int alpha = j1, beta = j2, gamma = j3;
struct {
double operator() (const int a, const int b, const int c,
const int alpha, const int beta,const int gamma,
const int t) {
return factorial(t)*factorial(c-b+t+alpha)*factorial(c-a+t-beta) * factorial(a+b-c-t)*factorial(a-t-alpha)*factorial(b-t+beta);
double operator()(const int a, const int b, const int c, const int alpha, const int beta,
const int t)
{
return factorial(t) * factorial(c - b + t + alpha) * factorial(c - a + t - beta) *
factorial(a + b - c - t) * factorial(a - t - alpha) * factorial(b - t + beta);
}
} x;
const double
sgn = 1 - 2*((a-b-gamma)&1),
g = sqrt(triangle_coeff(lmax,lmax,lmax)) * sqrt(factorial(a+alpha)*factorial(a-alpha)*
factorial(b+beta)*factorial(b-beta)*
const double sgn = 1 - 2 * ((a - b - gamma) & 1);
const double g = sqrt(triangle_coeff(lmax, lmax, lmax)) *
sqrt(factorial(a + alpha) * factorial(a - alpha) * factorial(b + beta) * factorial(b - beta) *
factorial(c + gamma) * factorial(c - gamma));
double s = 0;
int t = 0;
@ -721,7 +724,7 @@ double ComputeOrientOrderAtom::w3j(const int lmax, const int j1, const int j2, c
if (a - t - alpha < 0) break; // t<=lmax-j1
if (b - t + beta < 0) break; // t<=lmax+j2
const int m1t = 1 - 2 * (t & 1);
s += m1t/x(lmax,lmax,lmax,alpha,beta,gamma,t);
s += m1t / x(lmax, lmax, lmax, alpha, beta, t);
t++;
}
return sgn * g * s;