/* If primitive could not be found, primitive->size = -1 is returned. */
static Cell * get_primitive( int * mapping_table,
SPGCONST Cell * cell,
const VecDBL * pure_trans,
const double symprec )
{
int multi;
double prim_lattice[3][3];
Cell * primitive;
/* Primitive lattice vectors are searched. */
/* To be consistent, sometimes tolerance is decreased iteratively. */
/* The descreased tolerance is stored in 'static double tolerance'. */
multi = get_primitive_lattice_vectors_iterative( prim_lattice,
cell,
pure_trans,
symprec );
if ( ! multi ) {
goto not_found;
}
primitive = cel_alloc_cell( cell->size / multi );
if ( ! lat_smallest_lattice_vector( primitive->lattice,
prim_lattice,
symprec ) ) {
cel_free_cell( primitive );
goto not_found;
}
/* Fit atoms into new primitive cell */
if ( ! trim_cell( primitive, mapping_table, cell, symprec ) ) {
cel_free_cell( primitive );
goto not_found;
}
debug_print("Original cell lattice.\n");
debug_print_matrix_d3(cell->lattice);
debug_print("Found primitive lattice after choosing least axes.\n");
debug_print_matrix_d3(primitive->lattice);
debug_print("Number of atoms in primitive cell: %d\n", primitive->size);
debug_print("Volume: original %f --> primitive %f\n",
mat_get_determinant_d3(cell->lattice),
mat_get_determinant_d3(primitive->lattice));
/* found */
return primitive;
not_found:
primitive = cel_alloc_cell( -1 );
warning_print("spglib: Primitive cell could not found ");
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
return primitive;
}
/* }} */
int mat_inverse_matrix_d3(double m[3][3],
SPGCONST double a[3][3],
const double precision)
{
double det;
double c[3][3];
det = mat_get_determinant_d3(a);
if (mat_Dabs(det) < precision) {
warning_print("spglib: No inverse matrix (det=%f)\n", det);
debug_print("No inverse matrix\n");
return 0;
}
c[0][0] = (a[1][1] * a[2][2] - a[1][2] * a[2][1]) / det;
c[1][0] = (a[1][2] * a[2][0] - a[1][0] * a[2][2]) / det;
c[2][0] = (a[1][0] * a[2][1] - a[1][1] * a[2][0]) / det;
c[0][1] = (a[2][1] * a[0][2] - a[2][2] * a[0][1]) / det;
c[1][1] = (a[2][2] * a[0][0] - a[2][0] * a[0][2]) / det;
c[2][1] = (a[2][0] * a[0][1] - a[2][1] * a[0][0]) / det;
c[0][2] = (a[0][1] * a[1][2] - a[0][2] * a[1][1]) / det;
c[1][2] = (a[0][2] * a[1][0] - a[0][0] * a[1][2]) / det;
c[2][2] = (a[0][0] * a[1][1] - a[0][1] * a[1][0]) / det;
mat_copy_matrix_d3(m, c);
return 1;
}
/* Reference can be found in International table A. */
static int get_Delaunay_reduction( double red_lattice[3][3],
SPGCONST double lattice[3][3],
const double symprec )
{
int i, j;
double volume;
double basis[4][3];
get_exteneded_basis(basis, lattice);
while (1) {
if (get_Delaunay_reduction_basis(basis, symprec)) {
break;
}
}
get_Delaunay_shortest_vectors( basis, symprec );
for ( i = 0; i < 3; i++ ) {
for ( j = 0; j < 3; j++ ) {
red_lattice[i][j] = basis[j][i];
}
}
volume = mat_get_determinant_d3( red_lattice );
if ( mat_Dabs( volume ) < symprec ) {
warning_print("spglib: Minimum lattice has no volume (line %d, %s).\n", __LINE__, __FILE__);
goto err;
}
if ( volume < 0 ) {
/* Flip axes */
for (i = 0; i < 3; i++) {
for ( j = 0; j < 3; j++ ) {
red_lattice[i][j] = -red_lattice[i][j];
}
}
}
#ifdef DEBUG
debug_print("Delaunay reduction:\n");
debug_print_matrix_d3(red_lattice);
double metric[3][3];
mat_get_metric( metric, red_lattice );
debug_print("It's metric tensor.\n");
debug_print_matrix_d3( metric );
#endif
return 1;
err:
return 0;
}
/* Return 0 if failed */
static int get_Delaunay_reduction(double red_lattice[3][3],
SPGCONST double lattice[3][3],
const double symprec)
{
int i, j;
double volume, sum;
double basis[4][3];
get_exteneded_basis(basis, lattice);
sum = 0;
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
sum += basis[i][j] * basis[i][j];
}
}
while (1) {
if (get_Delaunay_reduction_basis(basis, symprec)) {
break;
}
}
get_Delaunay_shortest_vectors(basis, symprec);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
red_lattice[i][j] = basis[j][i];
}
}
volume = mat_get_determinant_d3(red_lattice);
if (mat_Dabs(volume) < symprec) {
warning_print("spglib: Minimum lattice has no volume (line %d, %s).\n", __LINE__, __FILE__);
goto err;
}
if (volume < 0) {
/* Flip axes */
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
red_lattice[i][j] = -red_lattice[i][j];
}
}
}
return 1;
err:
return 0;
}
static void get_Delaunay_shortest_vectors( double basis[4][3],
const double symprec )
{
int i, j;
double tmpmat[3][3], b[7][3], tmpvec[3];
/* Search in the set {b1, b2, b3, b4, b1+b2, b2+b3, b3+b1} */
for ( i = 0; i < 4; i++ ) {
for ( j = 0; j < 3; j++ ) {
b[i][j] = basis[i][j];
}
}
for ( i = 0; i < 3; i++ ) {
b[4][i] = basis[0][i] + basis[1][i];
}
for ( i = 0; i < 3; i++ ) {
b[5][i] = basis[1][i] + basis[2][i];
}
for ( i = 0; i < 3; i++ ) {
b[6][i] = basis[2][i] + basis[0][i];
}
/* Bubble sort */
for ( i = 0; i < 6; i++ ) {
for ( j = 0; j < 6; j++ ) {
if ( mat_norm_squared_d3( b[j] ) > mat_norm_squared_d3( b[j+1] ) ) {
mat_copy_vector_d3( tmpvec, b[j] );
mat_copy_vector_d3( b[j], b[j+1] );
mat_copy_vector_d3( b[j+1], tmpvec );
}
}
}
for ( i = 2; i < 7; i++ ) {
for ( j = 0; j < 3; j++ ) {
tmpmat[j][0] = b[0][j];
tmpmat[j][1] = b[1][j];
tmpmat[j][2] = b[i][j];
}
if ( mat_Dabs( mat_get_determinant_d3( tmpmat ) ) > symprec ) {
for ( j = 0; j < 3; j++ ) {
basis[0][j] = b[0][j];
basis[1][j] = b[1][j];
basis[2][j] = b[i][j];
}
break;
}
}
}
static PointSymmetry
transform_pointsymmetry(SPGCONST PointSymmetry * lat_sym_orig,
SPGCONST double new_lattice[3][3],
SPGCONST double original_lattice[3][3])
{
int i, size;
double trans_mat[3][3], inv_mat[3][3], drot[3][3];
PointSymmetry lat_sym_new;
lat_sym_new.size = 0;
mat_inverse_matrix_d3(inv_mat, original_lattice, 0);
mat_multiply_matrix_d3(trans_mat, inv_mat, new_lattice);
size = 0;
for (i = 0; i < lat_sym_orig->size; i++) {
mat_cast_matrix_3i_to_3d(drot, lat_sym_orig->rot[i]);
mat_get_similar_matrix_d3(drot, drot, trans_mat, 0);
/* new_lattice may have lower point symmetry than original_lattice.*/
/* The operations that have non-integer elements are not counted. */
if (mat_is_int_matrix(drot, mat_Dabs(mat_get_determinant_d3(trans_mat)) / 10)) {
mat_cast_matrix_3d_to_3i(lat_sym_new.rot[size], drot);
if (abs(mat_get_determinant_i3(lat_sym_new.rot[size])) != 1) {
warning_print("spglib: A point symmetry operation is not unimodular.");
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
goto err;
}
size++;
}
}
#ifdef SPGWARNING
if (! (lat_sym_orig->size == size)) {
warning_print("spglib: Some of point symmetry operations were dropped.");
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
}
#endif
lat_sym_new.size = size;
return lat_sym_new;
err:
return lat_sym_new;
}
static int mat_inverse_matrix_d3(double m[3][3],
double a[3][3],
const double precision)
{
double det;
double c[3][3];
det = mat_get_determinant_d3(a);
c[0][0] = (a[1][1] * a[2][2] - a[1][2] * a[2][1]) / det;
c[1][0] = (a[1][2] * a[2][0] - a[1][0] * a[2][2]) / det;
c[2][0] = (a[1][0] * a[2][1] - a[1][1] * a[2][0]) / det;
c[0][1] = (a[2][1] * a[0][2] - a[2][2] * a[0][1]) / det;
c[1][1] = (a[2][2] * a[0][0] - a[2][0] * a[0][2]) / det;
c[2][1] = (a[2][0] * a[0][1] - a[2][1] * a[0][0]) / det;
c[0][2] = (a[0][1] * a[1][2] - a[0][2] * a[1][1]) / det;
c[1][2] = (a[0][2] * a[1][0] - a[0][0] * a[1][2]) / det;
c[2][2] = (a[0][0] * a[1][1] - a[0][1] * a[1][0]) / det;
mat_copy_matrix_d3(m, c);
return 1;
}
/* }} */
int mat_inverse_matrix_d3(double m[3][3], const double a[3][3], const double precision)
{
double det;
double c[3][3];
det = mat_get_determinant_d3(a);
if (mat_Dabs(det) < precision) {
fprintf(stderr, "spglib: No inverse matrix\n");
return 0;
}
c[0][0] = (a[1][1] * a[2][2] - a[1][2] * a[2][1]) / det;
c[1][0] = (a[1][2] * a[2][0] - a[1][0] * a[2][2]) / det;
c[2][0] = (a[1][0] * a[2][1] - a[1][1] * a[2][0]) / det;
c[0][1] = (a[2][1] * a[0][2] - a[2][2] * a[0][1]) / det;
c[1][1] = (a[2][2] * a[0][0] - a[2][0] * a[0][2]) / det;
c[2][1] = (a[2][0] * a[0][1] - a[2][1] * a[0][0]) / det;
c[0][2] = (a[0][1] * a[1][2] - a[0][2] * a[1][1]) / det;
c[1][2] = (a[0][2] * a[1][0] - a[0][0] * a[1][2]) / det;
c[2][2] = (a[0][0] * a[1][1] - a[0][1] * a[1][0]) / det;
mat_copy_matrix_d3(m, c);
return 1;
}
/* Return 0 if failed */
static int change_basis_tricli(int int_transform_mat[3][3],
SPGCONST double conv_lattice[3][3],
SPGCONST double primitive_lattice[3][3],
const double symprec)
{
int i, j;
double niggli_cell[9];
double smallest_lattice[3][3], inv_lattice[3][3], transform_mat[3][3];
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
niggli_cell[i * 3 + j] = conv_lattice[i][j];
}
}
if (! niggli_reduce(niggli_cell, symprec * symprec)) {
return 0;
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
smallest_lattice[i][j] = niggli_cell[i * 3 + j];
}
}
if (mat_get_determinant_d3(smallest_lattice) < 0) {
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
smallest_lattice[i][j] = -smallest_lattice[i][j];
}
}
}
mat_inverse_matrix_d3(inv_lattice, primitive_lattice, 0);
mat_multiply_matrix_d3(transform_mat, inv_lattice, smallest_lattice);
mat_cast_matrix_3d_to_3i(int_transform_mat, transform_mat);
return 1;
}
/* Return 0 if failed */
static int get_primitive_lattice_vectors(double prim_lattice[3][3],
const VecDBL * vectors,
SPGCONST Cell * cell,
const double symprec)
{
int i, j, k, size;
double initial_volume, volume;
double relative_lattice[3][3], min_vectors[3][3], tmp_lattice[3][3];
double inv_mat_dbl[3][3];
int inv_mat_int[3][3];
debug_print("get_primitive_lattice_vectors:\n");
size = vectors->size;
initial_volume = mat_Dabs(mat_get_determinant_d3(cell->lattice));
/* check volumes of all possible lattices, find smallest volume */
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
for (k = j + 1; k < size; k++) {
mat_multiply_matrix_vector_d3(tmp_lattice[0],
cell->lattice,
vectors->vec[i]);
mat_multiply_matrix_vector_d3(tmp_lattice[1],
cell->lattice,
vectors->vec[j]);
mat_multiply_matrix_vector_d3(tmp_lattice[2],
cell->lattice,
vectors->vec[k]);
volume = mat_Dabs(mat_get_determinant_d3(tmp_lattice));
if (volume > symprec) {
if (mat_Nint(initial_volume / volume) == size-2) {
mat_copy_vector_d3(min_vectors[0], vectors->vec[i]);
mat_copy_vector_d3(min_vectors[1], vectors->vec[j]);
mat_copy_vector_d3(min_vectors[2], vectors->vec[k]);
goto ret;
}
}
}
}
}
/* Not found */
warning_print("spglib: Primitive lattice vectors cound not be found ");
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
return 0;
/* Found */
ret:
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
relative_lattice[j][i] = min_vectors[i][j];
}
}
mat_inverse_matrix_d3(inv_mat_dbl, relative_lattice, 0);
mat_cast_matrix_3d_to_3i(inv_mat_int, inv_mat_dbl);
if (abs(mat_get_determinant_i3(inv_mat_int)) == size-2) {
mat_cast_matrix_3i_to_3d(inv_mat_dbl, inv_mat_int);
mat_inverse_matrix_d3(relative_lattice, inv_mat_dbl, 0);
} else {
warning_print("spglib: Primitive lattice cleaning is incomplete ");
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
}
mat_multiply_matrix_d3(prim_lattice, cell->lattice, relative_lattice);
return 1;
}
/* Return NULL if failed */
static Cell * trim_cell(int * mapping_table,
SPGCONST double trimmed_lattice[3][3],
const Cell * cell,
const double symprec)
{
int i, index_atom, ratio;
Cell *trimmed_cell;
VecDBL * position;
int *overlap_table;
position = NULL;
overlap_table = NULL;
trimmed_cell = NULL;
ratio = abs(mat_Nint(mat_get_determinant_d3(cell->lattice) /
mat_get_determinant_d3(trimmed_lattice)));
/* Check if cell->size is dividable by ratio */
if ((cell->size / ratio) * ratio != cell->size) {
return NULL;
}
if ((trimmed_cell = cel_alloc_cell(cell->size / ratio)) == NULL) {
return NULL;
}
if ((position = translate_atoms_in_trimmed_lattice(cell,
trimmed_lattice))
== NULL) {
cel_free_cell(trimmed_cell);
trimmed_cell = NULL;
goto err;
}
mat_copy_matrix_d3(trimmed_cell->lattice, trimmed_lattice);
if ((overlap_table = get_overlap_table(position,
cell->size,
cell->types,
trimmed_cell,
symprec)) == NULL) {
mat_free_VecDBL(position);
position = NULL;
cel_free_cell(trimmed_cell);
trimmed_cell = NULL;
goto err;
}
index_atom = 0;
for (i = 0; i < cell->size; i++) {
if (overlap_table[i] == i) {
mapping_table[i] = index_atom;
trimmed_cell->types[index_atom] = cell->types[i];
index_atom++;
} else {
mapping_table[i] = mapping_table[overlap_table[i]];
}
}
set_positions(trimmed_cell,
position,
mapping_table,
overlap_table);
mat_free_VecDBL(position);
position = NULL;
free(overlap_table);
return trimmed_cell;
err:
return NULL;
}
static int get_Delaunay_reduction_2D(double red_lattice[3][3],
SPGCONST double lattice[3][3],
const int unique_axis,
const double symprec)
{
int i, j, k;
double volume;
double basis[3][3], lattice_2D[3][2], unique_vec[3];
k = 0;
for (i = 0; i < 3; i++) {
unique_vec[i] = lattice[i][unique_axis];
}
for (i = 0; i < 3; i++) {
if (i != unique_axis) {
for (j = 0; j < 3; j++) {
lattice_2D[j][k] = lattice[j][i];
}
k++;
}
}
get_exteneded_basis_2D(basis, lattice_2D);
while (1) {
if (get_Delaunay_reduction_basis_2D(basis, symprec)) {
break;
}
}
get_Delaunay_shortest_vectors_2D(basis, unique_vec, symprec);
k = 0;
for (i = 0; i < 3; i++) {
if (i == unique_axis) {
for (j = 0; j < 3; j++) {
red_lattice[j][i] = lattice[j][i];
}
} else {
for (j = 0; j < 3; j++) {
red_lattice[j][i] = basis[k][j];
}
k++;
}
}
volume = mat_get_determinant_d3(red_lattice);
if (mat_Dabs(volume) < symprec) {
warning_print("spglib: Minimum lattice has no volume (line %d, %s).\n", __LINE__, __FILE__);
goto err;
}
if (volume < 0) {
for (i = 0; i < 3; i++) {
red_lattice[i][unique_axis] = -red_lattice[i][unique_axis];
}
}
return 1;
err:
return 0;
}
