int main(void)
{
int i;
int mesh[3] = {5, 5, 5};
int is_shift[3] = {1, 1, 1};
int address_double[3];
int num_gp = mesh[0] * mesh[1] * mesh[2];
int grid_address[num_gp][3];
kgd_get_all_grid_addresses(grid_address, mesh);
printf("index : grid : double-grid (shift)\n");
for (i = 0; i < num_gp; i ++) {
kgd_get_grid_address_double_mesh(address_double,
grid_address[i],
mesh,
is_shift);
printf("%5d : %3d %3d %3d : %3d %3d %3d (%d %d %d)\n", i,
grid_address[i][0],
grid_address[i][1],
grid_address[i][2],
address_double[0],
address_double[1],
address_double[2],
(is_shift[0] != 0),
(is_shift[1] != 0),
(is_shift[2] != 0));
}
return 0;
}
static int get_ir_reciprocal_mesh_distortion(int grid_address[][3],
int ir_mapping_table[],
const int mesh[3],
const int is_shift[3],
const MatINT *rot_reciprocal)
{
int i, j, k, grid_point_rot, indivisible;
int address_double[3], address_double_rot[3], divisor[3];
kgd_get_all_grid_addresses(grid_address, mesh);
for (i = 0; i < 3; i++) {
divisor[i] = mesh[(i + 1) % 3] * mesh[(i + 2) % 3];
}
#pragma omp parallel for private(j, k, grid_point_rot, address_double, address_double_rot)
for (i = 0; i < mesh[0] * mesh[1] * mesh[2]; i++) {
kgd_get_grid_address_double_mesh(address_double,
grid_address[i],
mesh,
is_shift);
for (j = 0; j < 3; j++) {
address_double[j] *= divisor[j];
}
ir_mapping_table[i] = i;
for (j = 0; j < rot_reciprocal->size; j++) {
mat_multiply_matrix_vector_i3(address_double_rot,
rot_reciprocal->mat[j],
address_double);
for (k = 0; k < 3; k++) {
indivisible = address_double_rot[k] % divisor[k];
if (indivisible) {break;}
address_double_rot[k] /= divisor[k];
if ((address_double_rot[k] % 2 != 0 && is_shift[k] == 0) ||
(address_double_rot[k] % 2 == 0 && is_shift[k] == 1)) {
indivisible = 1;
break;
}
}
if (indivisible) {continue;}
grid_point_rot = kgd_get_grid_point_double_mesh(address_double_rot, mesh);
if (grid_point_rot < ir_mapping_table[i]) {
#ifdef _OPENMP
ir_mapping_table[i] = grid_point_rot;
#else
ir_mapping_table[i] = ir_mapping_table[grid_point_rot];
break;
#endif
}
}
}
return get_num_ir(ir_mapping_table, mesh);
}
/*---------*/
int spg_get_grid_point_from_address(const int grid_address[3],
const int mesh[3])
{
int address_double[3];
int is_shift[3];
is_shift[0] = 0;
is_shift[1] = 0;
is_shift[2] = 0;
kgd_get_grid_address_double_mesh(address_double,
grid_address,
mesh,
is_shift);
return kgd_get_grid_point_double_mesh(address_double, mesh);
}
static int get_ir_reciprocal_mesh_normal(int grid_address[][3],
int ir_mapping_table[],
const int mesh[3],
const int is_shift[3],
const MatINT *rot_reciprocal)
{
/* In the following loop, mesh is doubled. */
/* Even and odd mesh numbers correspond to */
/* is_shift[i] are 0 or 1, respectively. */
/* is_shift = [0,0,0] gives Gamma center mesh. */
/* grid: reducible grid points */
/* ir_mapping_table: the mapping from each point to ir-point. */
int i, j, grid_point_rot;
int address_double[3], address_double_rot[3];
kgd_get_all_grid_addresses(grid_address, mesh);
#pragma omp parallel for private(j, grid_point_rot, address_double, address_double_rot)
for (i = 0; i < mesh[0] * mesh[1] * mesh[2]; i++) {
kgd_get_grid_address_double_mesh(address_double,
grid_address[i],
mesh,
is_shift);
ir_mapping_table[i] = i;
for (j = 0; j < rot_reciprocal->size; j++) {
mat_multiply_matrix_vector_i3(address_double_rot,
rot_reciprocal->mat[j],
address_double);
grid_point_rot = kgd_get_grid_point_double_mesh(address_double_rot, mesh);
if (grid_point_rot < ir_mapping_table[i]) {
#ifdef _OPENMP
ir_mapping_table[i] = grid_point_rot;
#else
ir_mapping_table[i] = ir_mapping_table[grid_point_rot];
break;
#endif
}
}
}
return get_num_ir(ir_mapping_table, mesh);
}
