scnc
/
phonopy
mirror of https://github.com/phonopy/phonopy.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
phonopy/c/spglib/spacegroup.c

1526 lines
48 KiB
C
Raw Blame History

/* Copyright (C) 2010 Atsushi Togo */
/* All rights reserved. */
/* This file is part of spglib. */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following conditions */
/* are met: */
/* * Redistributions of source code must retain the above copyright */
/* notice, this list of conditions and the following disclaimer. */
/* * Redistributions in binary form must reproduce the above copyright */
/* notice, this list of conditions and the following disclaimer in */
/* the documentation and/or other materials provided with the */
/* distribution. */
/* * Neither the name of the phonopy project nor the names of its */
/* contributors may be used to endorse or promote products derived */
/* from this software without specific prior written permission. */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE */
/* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, */
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, */
/* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; */
/* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */
/* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT */
/* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN */
/* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cell.h"
#include "delaunay.h"
#include "hall_symbol.h"
#include "mathfunc.h"
#include "niggli.h"
#include "pointgroup.h"
#include "primitive.h"
#include "spacegroup.h"
#include "spg_database.h"
#include "symmetry.h"
#include "debug.h"
#define REDUCE_RATE 0.95
#define NUM_ATTEMPT 100
#define INT_PREC 0.1
static double change_of_basis_monocli[36][3][3] = {
{{ 1, 0, 0 }, /* b first turn; two axes are flipped in second turn */
{ 0, 1, 0 },
{ 0, 0, 1 }},
{{ 0, 0, 1 }, /* b */
{ 0,-1, 0 },
{ 1, 0, 0 }},
{{ 0, 0, 1 }, /* a */
{ 1, 0, 0 },
{ 0, 1, 0 }},
{{ 1, 0, 0 }, /* c */
{ 0, 0, 1 },
{ 0,-1, 0 }},
{{ 0, 1, 0 }, /* c */
{ 0, 0, 1 },
{ 1, 0, 0 }},
{{ 0,-1, 0 }, /* a */
{ 1, 0, 0 },
{ 0, 0, 1 }},
{{-1, 0, 1 }, /* b */
{ 0, 1, 0 },
{-1, 0, 0 }},
{{ 1, 0,-1 }, /* b */
{ 0,-1, 0 },
{ 0, 0,-1 }},
{{ 0, 1,-1 }, /* a */
{ 1, 0, 0 },
{ 0, 0,-1 }},
{{-1,-1, 0 }, /* c */
{ 0, 0, 1 },
{-1, 0, 0 }},
{{ 1,-1, 0 }, /* c */
{ 0, 0, 1 },
{ 0,-1, 0 }},
{{ 0, 1, 1 }, /* a */
{ 1, 0, 0 },
{ 0, 1, 0 }},
{{ 0, 0,-1 }, /* b */
{ 0, 1, 0 },
{ 1, 0,-1 }},
{{-1, 0, 0 }, /* b */
{ 0,-1, 0 },
{-1, 0, 1 }},
{{ 0,-1, 0 }, /* a */
{ 1, 0, 0 },
{ 0,-1, 1 }},
{{ 0, 1, 0 }, /* c */
{ 0, 0, 1 },
{ 1, 1, 0 }},
{{-1, 0, 0 }, /* c */
{ 0, 0, 1 },
{-1, 1, 0 }},
{{ 0, 0,-1 }, /* a */
{ 1, 0, 0 },
{ 0,-1,-1 }},
{{ 1, 0, 0 }, /* b two axes are flipped to look for non-acute axes */
{ 0,-1, 0 },
{ 0, 0,-1 }},
{{ 0, 0,-1 }, /* b */
{ 0, 1, 0 },
{ 1, 0, 0 }},
{{ 0, 0, 1 }, /* a */
{-1, 0, 0 },
{ 0,-1, 0 }},
{{-1, 0, 0 }, /* c */
{ 0, 0,-1 },
{ 0,-1, 0 }},
{{ 0, 1, 0 }, /* c */
{ 0, 0,-1 },
{-1, 0, 0 }},
{{ 0, 1, 0 }, /* a */
{-1, 0, 0 },
{ 0, 0, 1 }},
{{-1, 0,-1 }, /* b */
{ 0,-1, 0 },
{-1, 0, 0 }},
{{ 1, 0, 1 }, /* b */
{ 0, 1, 0 },
{ 0, 0, 1 }},
{{ 0,-1,-1 }, /* a */
{-1, 0, 0 },
{ 0, 0,-1 }},
{{ 1,-1, 0 }, /* c */
{ 0, 0,-1 },
{ 1, 0, 0 }},
{{-1,-1, 0 }, /* c */
{ 0, 0,-1 },
{ 0,-1, 0 }},
{{ 0,-1, 1 }, /* a */
{-1, 0, 0 },
{ 0,-1, 0 }},
{{ 0, 0, 1 }, /* b */
{ 0,-1, 0 },
{ 1, 0, 1 }},
{{-1, 0, 0 }, /* b */
{ 0, 1, 0 },
{-1, 0,-1 }},
{{ 0, 1, 0 }, /* a */
{-1, 0, 0 },
{ 0, 1, 1 }},
{{ 0, 1, 0 }, /* c */
{ 0, 0,-1 },
{-1, 1, 0 }},
{{ 1, 0, 0 }, /* c */
{ 0, 0,-1 },
{ 1, 1, 0 }},
{{ 0, 0,-1 }, /* a */
{-1, 0, 0 },
{ 0, 1,-1 }}};
static Centering change_of_centering_monocli[36] = {
C_FACE, /* first turn */
A_FACE,
B_FACE,
B_FACE,
A_FACE,
C_FACE,
BASE,
BASE,
BASE,
BASE,
BASE,
BASE,
A_FACE,
C_FACE,
C_FACE,
A_FACE,
B_FACE,
B_FACE,
C_FACE, /* second turn */
A_FACE,
B_FACE,
B_FACE,
A_FACE,
C_FACE,
BASE,
BASE,
BASE,
BASE,
BASE,
BASE,
A_FACE,
C_FACE,
C_FACE,
A_FACE,
B_FACE,
B_FACE};
static int change_of_unique_axis_monocli[36] = {
1, 1, 0, 2, 2, 0, 1, 1, 0, 2, 2, 0, 1, 1, 0, 2, 2, 0,
1, 1, 0, 2, 2, 0, 1, 1, 0, 2, 2, 0, 1, 1, 0, 2, 2, 0};
static double change_of_basis_ortho[6][3][3] = {{{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }},
{{ 0, 0, 1 },
{ 1, 0, 0 },
{ 0, 1, 0 }},
{{ 0, 1, 0 },
{ 0, 0, 1 },
{ 1, 0, 0 }},
{{ 0, 1, 0 },
{ 1, 0, 0 },
{ 0, 0,-1 }},
{{ 1, 0, 0 },
{ 0, 0, 1 },
{ 0,-1, 0 }},
{{ 0, 0, 1 },
{ 0, 1, 0 },
{-1, 0, 0 }}};
static Centering change_of_centering_ortho[6] = {C_FACE,
B_FACE,
A_FACE,
C_FACE,
B_FACE,
A_FACE};
static int change_of_unique_axis_ortho[6] = {2, 1, 0, 2, 1, 0};
static double hR_to_hP[3][3] = {{ 1, 0, 1 },
{-1, 1, 1 },
{ 0,-1, 1 }};
static double change_of_basis_501[3][3] = {{ 0, 0, 1},
{ 0,-1, 0},
{ 1, 0, 0}};
static int spacegroup_to_hall_number[230] = {
1, 2, 3, 6, 9, 18, 21, 30, 39, 57,
60, 63, 72, 81, 90, 108, 109, 112, 115, 116,
119, 122, 123, 124, 125, 128, 134, 137, 143, 149,
155, 161, 164, 170, 173, 176, 182, 185, 191, 197,
203, 209, 212, 215, 218, 221, 227, 228, 230, 233,
239, 245, 251, 257, 263, 266, 269, 275, 278, 284,
290, 292, 298, 304, 310, 313, 316, 322, 334, 335,
337, 338, 341, 343, 349, 350, 351, 352, 353, 354,
355, 356, 357, 358, 359, 361, 363, 364, 366, 367,
368, 369, 370, 371, 372, 373, 374, 375, 376, 377,
378, 379, 380, 381, 382, 383, 384, 385, 386, 387,
388, 389, 390, 391, 392, 393, 394, 395, 396, 397,
398, 399, 400, 401, 402, 404, 406, 407, 408, 410,
412, 413, 414, 416, 418, 419, 420, 422, 424, 425,
426, 428, 430, 431, 432, 433, 435, 436, 438, 439,
440, 441, 442, 443, 444, 446, 447, 448, 449, 450,
452, 454, 455, 456, 457, 458, 460, 462, 463, 464,
465, 466, 467, 468, 469, 470, 471, 472, 473, 474,
475, 476, 477, 478, 479, 480, 481, 482, 483, 484,
485, 486, 487, 488, 489, 490, 491, 492, 493, 494,
495, 497, 498, 500, 501, 502, 503, 504, 505, 506,
507, 508, 509, 510, 511, 512, 513, 514, 515, 516,
517, 518, 520, 521, 523, 524, 525, 527, 529, 530,
};
static double identity[3][3] = {{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }};
static double monocli_i2c[3][3] = {{ 1, 0,-1 },
{ 0, 1, 0 },
{ 1, 0, 0 }};
static double monocli_a2c[3][3] = {{ 0, 0, 1 },
{ 0,-1, 0 },
{ 1, 0, 0 }};
static double rhombo_obverse[3][3] = {{ 2./3,-1./3,-1./3 },
{ 1./3, 1./3,-2./3 },
{ 1./3, 1./3, 1./3 }};
static double rhomb_reverse[3][3] = {{ 1./3,-2./3, 1./3 },
{ 2./3,-1./3,-1./3 },
{ 1./3, 1./3, 1./3 }};
static double a2c[3][3] = {{ 0, 0, 1 },
{ 1, 0, 0 },
{ 0, 1, 0 }};
static double b2c[3][3] = {{ 0, 1, 0 },
{ 0, 0, 1 },
{ 1, 0, 0 }};
static double A_mat[3][3] = {{ 1, 0, 0},
{ 0, 1./2,-1./2},
{ 0, 1./2, 1./2}};
static double C_mat[3][3] = {{ 1./2, 1./2, 0},
{-1./2, 1./2, 0},
{ 0, 0, 1}};
static double R_mat[3][3] = {{ 2./3,-1./3,-1./3 },
{ 1./3, 1./3,-2./3 },
{ 1./3, 1./3, 1./3 }};
static double I_mat[3][3] = {{-1./2, 1./2, 1./2 },
{ 1./2,-1./2, 1./2 },
{ 1./2, 1./2,-1./2 }};
static double F_mat[3][3] = {{ 0, 1./2, 1./2 },
{ 1./2, 0, 1./2 },
{ 1./2, 1./2, 0 }};
static Spacegroup * search_spacegroup_with_symmetry(const Cell * primitive,
const int candidates[],
const int num_candidates,
const Symmetry *symmetry,
const double symprec,
const double angle_tolerance);
static Spacegroup * get_spacegroup(const int hall_number,
const double origin_shift[3],
SPGCONST double conv_lattice[3][3]);
static int iterative_search_hall_number(double origin_shift[3],
double conv_lattice[3][3],
const int candidates[],
const int num_candidates,
const Cell * primitive,
const Symmetry * symmetry,
const double symprec,
const double angle_tolerance);
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);
static int change_basis_monocli(int int_transform_mat[3][3],
SPGCONST double conv_lattice[3][3],
SPGCONST double primitive_lattice[3][3],
const double symprec);
static Symmetry *
get_initial_conventional_symmetry(const Centering centering,
SPGCONST double transform_mat[3][3],
const Symmetry * symmetry);
static int search_hall_number(double origin_shift[3],
double conv_lattice[3][3],
const int candidates[],
const int num_candidates,
SPGCONST double primitive_lattice[3][3],
const Symmetry * symmetry,
const double symprec);
static int match_hall_symbol_db(double origin_shift[3],
double lattice[3][3],
const int hall_number,
const int pointgroup_number,
const Holohedry holohedry,
const Centering centering,
const Symmetry *symmetry,
const double symprec);
static int match_hall_symbol_db_monocli(double origin_shift[3],
double lattice[3][3],
const int hall_number,
const int num_hall_types,
const Centering centering,
const Symmetry *symmetry,
const double symprec);
static int match_hall_symbol_db_ortho(double origin_shift[3],
double lattice[3][3],
const int hall_number,
const Centering centering,
const Symmetry *symmetry,
const int num_free_axes,
const double symprec);
static Symmetry * get_conventional_symmetry(SPGCONST double transform_mat[3][3],
const Centering centering,
const Symmetry *primitive_sym);
static Centering get_centering(double correction_mat[3][3],
SPGCONST int transform_mat[3][3],
const Laue laue);
static Centering get_base_center(SPGCONST int transform_mat[3][3]);
static int get_centering_shifts(double shift[3][3],
const Centering centering);
/* Return spacegroup.number = 0 if failed */
Spacegroup * spa_search_spacegroup(const Cell * primitive,
const int hall_number,
const double symprec,
const double angle_tolerance)
{
Spacegroup *spacegroup;
Symmetry *symmetry;
int candidate[1];
debug_print("search_spacegroup (tolerance = %f):\n", symprec);
symmetry = NULL;
spacegroup = NULL;
if ((symmetry = sym_get_operation(primitive, symprec, angle_tolerance)) ==
NULL) {
return NULL;
}
if (hall_number > 0) {
candidate[0] = hall_number;
}
if (hall_number) {
spacegroup = search_spacegroup_with_symmetry(primitive,
candidate,
1,
symmetry,
symprec,
angle_tolerance);
} else {
spacegroup = search_spacegroup_with_symmetry(primitive,
spacegroup_to_hall_number,
230,
symmetry,
symprec,
angle_tolerance);
}
sym_free_symmetry(symmetry);
symmetry = NULL;
return spacegroup;
}
/* Retrun 0 if failed */
int spa_search_spacegroup_with_symmetry(const Symmetry *symmetry,
const double symprec)
{
int i, hall_number;
Spacegroup *spacegroup;
Cell *primitive;
spacegroup = NULL;
primitive = cel_alloc_cell(1);
mat_copy_matrix_d3(primitive->lattice, identity);
for (i = 0; i < 3; i++) {
primitive->position[0][i] = 0;
}
spacegroup = search_spacegroup_with_symmetry(primitive,
spacegroup_to_hall_number,
230,
symmetry,
symprec,
-1.0);
if (spacegroup != NULL) {
hall_number = spacegroup->hall_number;
free(spacegroup);
spacegroup = NULL;
return hall_number;
} else {
return 0;
}
}
/* Return NULL if failed */
Cell * spa_transform_to_primitive(int * mapping_table,
const Cell * cell,
SPGCONST double trans_mat[3][3],
const Centering centering,
const double symprec)
{
double tmat[3][3], tmat_inv[3][3], prim_lat[3][3];
Cell * primitive;
primitive = NULL;
if (!mat_inverse_matrix_d3(tmat_inv, trans_mat, symprec)) {
goto err;
}
switch (centering) {
case PRIMITIVE:
mat_copy_matrix_d3(tmat, tmat_inv);
break;
case A_FACE:
mat_multiply_matrix_d3(tmat, tmat_inv, A_mat);
break;
case C_FACE:
mat_multiply_matrix_d3(tmat, tmat_inv, C_mat);
break;
case FACE:
mat_multiply_matrix_d3(tmat, tmat_inv, F_mat);
break;
case BODY:
mat_multiply_matrix_d3(tmat, tmat_inv, I_mat);
break;
case R_CENTER:
mat_multiply_matrix_d3(tmat, tmat_inv, R_mat);
break;
default:
goto err;
}
mat_multiply_matrix_d3(prim_lat, cell->lattice, tmat);
if ((primitive = cel_trim_cell(mapping_table, prim_lat, cell, symprec))
== NULL) {
warning_print("spglib: cel_trim_cell failed.");
warning_print(" (line %d, %s).\n", __LINE__, __FILE__);
}
return primitive;
err:
return NULL;
}
/* Return NULL if failed */
Cell * spa_transform_from_primitive(const Cell * primitive,
const Centering centering,
const double symprec)
{
int multi, i, j, k, num_atom;
int *mapping_table;
double tmat[3][3], inv_tmat[3][3], shift[3][3];
Cell *std_cell, *trimmed_cell;
mapping_table = NULL;
trimmed_cell = NULL;
std_cell = NULL;
switch (centering) {
case PRIMITIVE:
break;
case A_FACE:
mat_copy_matrix_d3(tmat, A_mat);
mat_inverse_matrix_d3(inv_tmat, A_mat, 0);
break;
case C_FACE:
mat_copy_matrix_d3(tmat, C_mat);
mat_inverse_matrix_d3(inv_tmat, C_mat, 0);
break;
case FACE:
mat_copy_matrix_d3(tmat, F_mat);
mat_inverse_matrix_d3(inv_tmat, F_mat, 0);
break;
case BODY:
mat_copy_matrix_d3(tmat, I_mat);
mat_inverse_matrix_d3(inv_tmat, I_mat, 0);
break;
case R_CENTER:
mat_copy_matrix_d3(tmat, R_mat);
mat_inverse_matrix_d3(inv_tmat, R_mat, 0);
break;
default:
goto ret;
}
multi = get_centering_shifts(shift, centering);
if ((mapping_table = (int*) malloc(sizeof(int) * primitive->size * multi))
== NULL) {
warning_print("spglib: Memory could not be allocated ");
goto ret;
}
if ((std_cell = cel_alloc_cell(primitive->size * multi)) == NULL) {
free(mapping_table);
mapping_table = NULL;
goto ret;
}
mat_multiply_matrix_d3(std_cell->lattice, primitive->lattice, inv_tmat);
num_atom = 0;
for (i = 0; i < primitive->size; i++) {
mat_multiply_matrix_vector_d3(std_cell->position[num_atom],
tmat,
primitive->position[i]);
std_cell->types[num_atom] = primitive->types[i];
num_atom++;
}
for (i = 0; i < multi - 1; i++) {
for (j = 0; j < primitive->size; j++) {
mat_copy_vector_d3(std_cell->position[num_atom],
std_cell->position[j]);
for (k = 0; k < 3; k++) {
std_cell->position[num_atom][k] += shift[i][k];
}
std_cell->types[num_atom] = std_cell->types[j];
num_atom++;
}
}
trimmed_cell = cel_trim_cell(mapping_table,
std_cell->lattice,
std_cell,
symprec);
cel_free_cell(std_cell);
std_cell = NULL;
free(mapping_table);
mapping_table = NULL;
ret:
return trimmed_cell;
}
/* Return NULL if failed */
static Spacegroup * search_spacegroup_with_symmetry(const Cell * primitive,
const int candidates[],
const int num_candidates,
const Symmetry *symmetry,
const double symprec,
const double angle_tolerance)
{
int hall_number;
double conv_lattice[3][3];
double origin_shift[3];
Spacegroup *spacegroup;
PointSymmetry pointsym;
debug_print("search_spacegroup (tolerance = %f):\n", symprec);
spacegroup = NULL;
pointsym = ptg_get_pointsymmetry(symmetry->rot, symmetry->size);
if (pointsym.size < symmetry->size) {
warning_print("spglib: Point symmetry of primitive cell is broken. ");
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
return NULL;
}
hall_number = iterative_search_hall_number(origin_shift,
conv_lattice,
candidates,
num_candidates,
primitive,
symmetry,
symprec,
angle_tolerance);
if (hall_number == 0) {
return NULL;
}
spacegroup = get_spacegroup(hall_number, origin_shift, conv_lattice);
return spacegroup;
}
/* Return spacegroup.number = 0 if failed */
static Spacegroup * get_spacegroup(const int hall_number,
const double origin_shift[3],
SPGCONST double conv_lattice[3][3])
{
Spacegroup *spacegroup;
SpacegroupType spacegroup_type;
spacegroup = NULL;
if ((spacegroup = (Spacegroup*) malloc(sizeof(Spacegroup))) == NULL) {
warning_print("spglib: Memory could not be allocated.");
return NULL;
}
if (0 < hall_number && hall_number < 531) {
spacegroup_type = spgdb_get_spacegroup_type(hall_number);
mat_copy_matrix_d3(spacegroup->bravais_lattice, conv_lattice);
mat_copy_vector_d3(spacegroup->origin_shift, origin_shift);
spacegroup->number = spacegroup_type.number;
spacegroup->hall_number = hall_number;
spacegroup->pointgroup_number = spacegroup_type.pointgroup_number;
strcpy(spacegroup->schoenflies, spacegroup_type.schoenflies);
strcpy(spacegroup->hall_symbol, spacegroup_type.hall_symbol);
strcpy(spacegroup->international, spacegroup_type.international);
strcpy(spacegroup->international_long, spacegroup_type.international_full);
strcpy(spacegroup->international_short,
spacegroup_type.international_short);
strcpy(spacegroup->choice, spacegroup_type.choice);
}
return spacegroup;
}
/* Return 0 if failed */
static int iterative_search_hall_number(double origin_shift[3],
double conv_lattice[3][3],
const int candidates[],
const int num_candidates,
const Cell * primitive,
const Symmetry * symmetry,
const double symprec,
const double angle_tolerance)
{
int attempt, hall_number;
double tolerance;
Symmetry * sym_reduced;
debug_print("iterative_search_hall_number:\n");
hall_number = 0;
sym_reduced = NULL;
hall_number = search_hall_number(origin_shift,
conv_lattice,
candidates,
num_candidates,
primitive->lattice,
symmetry,
symprec);
if (hall_number > 0) {
goto ret;
}
tolerance = symprec;
for (attempt = 0; attempt < NUM_ATTEMPT; attempt++) {
warning_print("spglib: Attempt %d tolerance = %e failed",
attempt, tolerance);
warning_print("(line %d, %s).\n", __LINE__, __FILE__);
tolerance *= REDUCE_RATE;
sym_reduced = sym_reduce_operation(primitive,
symmetry,
tolerance,
angle_tolerance);
hall_number = search_hall_number(origin_shift,
conv_lattice,
candidates,
num_candidates,
primitive->lattice,
sym_reduced,
symprec);
sym_free_symmetry(sym_reduced);
sym_reduced = NULL;
if (hall_number > 0) {
break;
}
}
ret:
return hall_number;
}
/* Return 0 if failed */
static int search_hall_number(double origin_shift[3],
double conv_lattice[3][3],
const int candidates[],
const int num_candidates,
SPGCONST double primitive_lattice[3][3],
const Symmetry * symmetry,
const double symprec)
{
int i, hall_number;
Centering centering;
Pointgroup pointgroup;
Symmetry * conv_symmetry;
int int_transform_mat[3][3];
double correction_mat[3][3], transform_mat[3][3];
debug_print("search_hall_number:\n");
hall_number = 0;
conv_symmetry = NULL;
pointgroup = ptg_get_transformation_matrix(int_transform_mat,
symmetry->rot,
symmetry->size);
if (pointgroup.number == 0) {
goto err;
}
mat_multiply_matrix_di3(conv_lattice, primitive_lattice, int_transform_mat);
if (pointgroup.laue == LAUE1) {
if (! change_basis_tricli(int_transform_mat,
conv_lattice,
primitive_lattice,
symprec)) {
goto err;
}
}
if (pointgroup.laue == LAUE2M) {
if (! change_basis_monocli(int_transform_mat,
conv_lattice,
primitive_lattice,
symprec)) {
goto err;
}
}
if ((centering = get_centering(correction_mat,
int_transform_mat,
pointgroup.laue)) == CENTERING_ERROR) {
goto err;
}
mat_multiply_matrix_id3(transform_mat, int_transform_mat, correction_mat);
mat_multiply_matrix_d3(conv_lattice, primitive_lattice, transform_mat);
if ((conv_symmetry = get_initial_conventional_symmetry(centering,
transform_mat,
symmetry)) == NULL) {
goto err;
}
for (i = 0; i < num_candidates; i++) {
if (match_hall_symbol_db(origin_shift,
conv_lattice, /* <-- modified only matched */
candidates[i],
pointgroup.number,
pointgroup.holohedry,
centering,
conv_symmetry,
symprec)) {
hall_number = candidates[i];
break;
}
}
sym_free_symmetry(conv_symmetry);
conv_symmetry = NULL;
return hall_number;
err:
return 0;
}
/* Triclinic: Niggli cell reduction */
/* 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;
}
/* Monoclinic: choose shortest a, c lattice vectors (|a| < |c|) */
/* Return 0 if failed */
static int change_basis_monocli(int int_transform_mat[3][3],
SPGCONST double conv_lattice[3][3],
SPGCONST double primitive_lattice[3][3],
const double symprec)
{
double smallest_lattice[3][3], inv_lattice[3][3], transform_mat[3][3];
if (! del_delaunay_reduce_2D(smallest_lattice,
conv_lattice,
1, /* unique axis of b */
symprec)) {
return 0;
}
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 NULL if failed */
static Symmetry *
get_initial_conventional_symmetry(const Centering centering,
SPGCONST double transform_mat[3][3],
const Symmetry * symmetry)
{
Symmetry * conv_symmetry;
debug_print("get_initial_conventional_symmetry\n");
conv_symmetry = NULL;
if (centering == R_CENTER) {
/* hP for rhombohedral */
conv_symmetry = get_conventional_symmetry(transform_mat,
PRIMITIVE,
symmetry);
} else {
conv_symmetry = get_conventional_symmetry(transform_mat,
centering,
symmetry);
}
return conv_symmetry;
}
/* Return 0 if failed */
static int match_hall_symbol_db(double origin_shift[3],
double lattice[3][3],
const int hall_number,
const int pointgroup_number,
const Holohedry holohedry,
const Centering centering,
const Symmetry *symmetry,
const double symprec)
{
int is_found, num_hall_types;
SpacegroupType spacegroup_type;
Symmetry * changed_symmetry;
double changed_lattice[3][3], inv_lattice[3][3], transform_mat[3][3];
changed_symmetry = NULL;
spacegroup_type = spgdb_get_spacegroup_type(hall_number);
num_hall_types = (spacegroup_to_hall_number[spacegroup_type.number] -
spacegroup_to_hall_number[spacegroup_type.number - 1]);
if (pointgroup_number != spacegroup_type.pointgroup_number) {
goto err;
}
switch (holohedry) {
case MONOCLI:
if (match_hall_symbol_db_monocli(origin_shift,
lattice,
hall_number,
num_hall_types,
centering,
symmetry,
symprec)) {return 1;}
break;
case ORTHO:
if (spacegroup_type.number == 48 ||
spacegroup_type.number == 50 ||
spacegroup_type.number == 59 ||
spacegroup_type.number == 68 ||
spacegroup_type.number == 70) { /* uncount origin shift */
num_hall_types /= 2;
}
if (num_hall_types == 1) {
if (match_hall_symbol_db_ortho(origin_shift,
lattice,
hall_number,
centering,
symmetry,
6,
symprec)) {return 1;}
break;
}
if (num_hall_types == 2) {
if (match_hall_symbol_db_ortho(origin_shift,
lattice,
hall_number,
centering,
symmetry,
3,
symprec)) {return 1;}
break;
}
if (num_hall_types == 3) {
mat_copy_matrix_d3(changed_lattice, lattice);
if (! match_hall_symbol_db_ortho
(origin_shift,
changed_lattice,
spacegroup_to_hall_number[spacegroup_type.number - 1],
centering,
symmetry,
0,
symprec)) {break;}
mat_inverse_matrix_d3(inv_lattice, lattice, 0);
mat_multiply_matrix_d3(transform_mat, inv_lattice, changed_lattice);
if ((changed_symmetry = get_conventional_symmetry(transform_mat,
PRIMITIVE,
symmetry)) == NULL) {
goto err;
}
is_found = match_hall_symbol_db_ortho(origin_shift,
changed_lattice,
hall_number,
centering,
changed_symmetry,
2,
symprec);
sym_free_symmetry(changed_symmetry);
changed_symmetry = NULL;
if (is_found) {
mat_copy_matrix_d3(lattice, changed_lattice);
return 1;
}
break;
}
if (num_hall_types == 6) {
if (match_hall_symbol_db_ortho(origin_shift,
lattice,
hall_number,
centering,
symmetry,
1,
symprec)) {return 1;}
break;
}
break;
case CUBIC:
if (hal_match_hall_symbol_db(origin_shift,
lattice,
hall_number,
centering,
symmetry,
symprec)) {return 1;}
if (hall_number == 501) { /* Try another basis for No.205 */
mat_multiply_matrix_d3(changed_lattice,
lattice,
change_of_basis_501);
if ((changed_symmetry = get_conventional_symmetry(change_of_basis_501,
PRIMITIVE,
symmetry)) == NULL) {
goto err;
}
is_found = hal_match_hall_symbol_db(origin_shift,
changed_lattice,
hall_number,
PRIMITIVE,
changed_symmetry,
symprec);
sym_free_symmetry(changed_symmetry);
changed_symmetry = NULL;
if (is_found) {
mat_copy_matrix_d3(lattice, changed_lattice);
return 1;
}
}
break;
case TRIGO:
if (centering == R_CENTER) {
if (hall_number == 433 ||
hall_number == 436 ||
hall_number == 444 ||
hall_number == 450 ||
hall_number == 452 ||
hall_number == 458 ||
hall_number == 460) {
mat_multiply_matrix_d3(changed_lattice, lattice, hR_to_hP);
if ((changed_symmetry =
get_conventional_symmetry(hR_to_hP, R_CENTER, symmetry)) == NULL) {
goto err;
}
is_found = hal_match_hall_symbol_db(origin_shift,
changed_lattice,
hall_number,
centering,
changed_symmetry,
symprec);
sym_free_symmetry(changed_symmetry);
changed_symmetry = NULL;
if (is_found) {
mat_copy_matrix_d3(lattice, changed_lattice);
return 1;
}
} else {
if (hal_match_hall_symbol_db(origin_shift,
lattice,
hall_number,
PRIMITIVE,
symmetry,
symprec)) {
return 1;
}
}
break;
}
/* Do not break for other trigonal cases */
default: /* HEXA, TETRA, TRICLI and rest of TRIGO */
if (hal_match_hall_symbol_db(origin_shift,
lattice,
hall_number,
centering,
symmetry,
symprec)) {
return 1;
}
break;
}
err:
return 0;
}
/* Return 0 if failed */
static int match_hall_symbol_db_monocli(double origin_shift[3],
double lattice[3][3],
const int hall_number,
const int num_hall_types,
const Centering centering,
const Symmetry *symmetry,
const double symprec)
{
int i, j, k, l, is_found;
double vec[2][3], norms[3];
Centering changed_centering;
Symmetry * changed_symmetry;
double changed_lattice[3][3];
changed_symmetry = NULL;
for (i = 0; i < 36; i++) {
/* centring type should be P or C */
if (centering == C_FACE) {
changed_centering = change_of_centering_monocli[i];
} else { /* suppose PRIMITIVE */
changed_centering = centering;
}
mat_multiply_matrix_d3(changed_lattice,
lattice,
change_of_basis_monocli[i]);
/* Make non-acute and length preference */
l = 0;
for (j = 0; j < 3; j++) {
if (j == change_of_unique_axis_monocli[i]) {continue;}
for (k = 0; k < 3; k++) {vec[l][k] = changed_lattice[k][j];}
norms[l] = mat_norm_squared_d3(vec[l]);
l++;
}
/* discard if principal angle is acute. */
if (vec[0][0] * vec[1][0] +
vec[0][1] * vec[1][1] +
vec[0][2] * vec[1][2] > 0) {
continue;
}
/* Choose |a| < |b| < |c| if there are freedom. */
if (num_hall_types == 3) {
if (norms[0] > norms[1]) {continue;}
}
if ((changed_symmetry =
get_conventional_symmetry(change_of_basis_monocli[i],
PRIMITIVE,
symmetry)) == NULL) {
goto err;
}
is_found = hal_match_hall_symbol_db(origin_shift,
changed_lattice,
hall_number,
changed_centering,
changed_symmetry,
symprec);
sym_free_symmetry(changed_symmetry);
changed_symmetry = NULL;
if (is_found) {
mat_copy_matrix_d3(lattice, changed_lattice);
return 1;
}
}
err:
return 0;
}
/* Return 0 if failed */
static int match_hall_symbol_db_ortho(double origin_shift[3],
double lattice[3][3],
const int hall_number,
const Centering centering,
const Symmetry *symmetry,
const int num_free_axes,
const double symprec)
{
int i, j, k, l, is_found;
double vec[3], norms[3];
Centering changed_centering;
Symmetry * changed_symmetry;
double changed_lattice[3][3];
changed_symmetry = NULL;
for (i = 0; i < 6; i++) {
if (centering == C_FACE) {
changed_centering = change_of_centering_ortho[i];
} else {
changed_centering = centering;
}
mat_multiply_matrix_d3(changed_lattice,
lattice,
change_of_basis_ortho[i]);
if (num_free_axes == 2) {
l = 0;
for (j = 0; j < 3; j++) {
if (j == change_of_unique_axis_ortho[i]) {continue;}
for (k = 0; k < 3; k++) {vec[k] = changed_lattice[k][j];}
norms[l] = mat_norm_squared_d3(vec);
l++;
}
if (norms[0] > norms[1]) {continue;}
}
if (num_free_axes == 3) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++) {vec[k] = changed_lattice[k][j];}
norms[j] = mat_norm_squared_d3(vec);
}
if (norms[0] > norms[1] || norms[0] > norms[2]) {continue;}
}
if (num_free_axes == 6) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++) {vec[k] = changed_lattice[k][j];}
norms[j] = mat_norm_squared_d3(vec);
}
if (norms[0] > norms[1] || norms[1] > norms[2]) {continue;}
}
if ((changed_symmetry = get_conventional_symmetry(change_of_basis_ortho[i],
PRIMITIVE,
symmetry)) == NULL) {
goto err;
}
is_found = hal_match_hall_symbol_db(origin_shift,
changed_lattice,
hall_number,
changed_centering,
changed_symmetry,
symprec);
sym_free_symmetry(changed_symmetry);
changed_symmetry = NULL;
if (is_found) {
mat_copy_matrix_d3(lattice, changed_lattice);
return 1;
}
}
err:
return 0;
}
/* Return NULL if failed */
static Symmetry * get_conventional_symmetry(SPGCONST double transform_mat[3][3],
const Centering centering,
const Symmetry *primitive_sym)
{
int i, j, k, multi, size;
double inv_tmat[3][3], shift[3][3];
double symmetry_rot_d3[3][3], primitive_sym_rot_d3[3][3];
Symmetry *symmetry;
symmetry = NULL;
size = primitive_sym->size;
switch (centering) {
case FACE:
if ((symmetry = sym_alloc_symmetry(size * 4)) == NULL) {
return NULL;
}
break;
case R_CENTER:
if ((symmetry = sym_alloc_symmetry(size * 3)) == NULL) {
return NULL;
}
break;
case BODY:
case A_FACE:
case B_FACE:
case C_FACE:
if ((symmetry = sym_alloc_symmetry(size * 2)) == NULL) {
return NULL;
}
break;
default:
if ((symmetry = sym_alloc_symmetry(size)) == NULL) {
return NULL;
}
break;
}
for (i = 0; i < size; i++) {
mat_cast_matrix_3i_to_3d(primitive_sym_rot_d3, primitive_sym->rot[i]);
/* C*S*C^-1: recover conventional cell symmetry operation */
mat_get_similar_matrix_d3(symmetry_rot_d3,
primitive_sym_rot_d3,
transform_mat,
0);
mat_cast_matrix_3d_to_3i(symmetry->rot[i], symmetry_rot_d3);
/* translation in conventional cell: C = B^-1*P */
mat_inverse_matrix_d3(inv_tmat, transform_mat, 0);
mat_multiply_matrix_vector_d3(symmetry->trans[i],
inv_tmat,
primitive_sym->trans[i]);
}
multi = 1;
if (centering != PRIMITIVE) {
multi = get_centering_shifts(shift, centering);
for (i = 0; i < multi - 1; i++) {
for (j = 0; j < size; j++) {
mat_copy_matrix_i3(symmetry->rot[(i+1) * size + j],
symmetry->rot[j]);
for (k = 0; k < 3; k++) {
symmetry->trans[(i+1) * size + j][k] =
symmetry->trans[j][k] + shift[i][k];
}
}
}
}
for (i = 0; i < multi; i++) {
for (j = 0; j < size; j++) {
for (k = 0; k < 3; k++) {
symmetry->trans[i * size + j][k] =
mat_Dmod1(symmetry->trans[i * size + j][k]);
}
}
}
return symmetry;
}
/* Return CENTERING_ERROR if failed */
static Centering get_centering(double correction_mat[3][3],
SPGCONST int transform_mat[3][3],
const Laue laue)
{
int det;
double trans_corr_mat[3][3];
Centering centering;
mat_copy_matrix_d3(correction_mat, identity);
det = abs(mat_get_determinant_i3(transform_mat));
debug_print("laue class: %d\n", laue);
debug_print("multiplicity: %d\n", det);
switch (det) {
case 1:
centering = PRIMITIVE;
break;
case 2:
centering = get_base_center(transform_mat);
if (centering == A_FACE) {
if (laue == LAUE2M) {
debug_print("Monocli A to C\n");
mat_copy_matrix_d3(correction_mat, monocli_a2c);
} else {
mat_copy_matrix_d3(correction_mat, a2c);
}
centering = C_FACE;
}
if (centering == B_FACE) {
mat_copy_matrix_d3(correction_mat, b2c);
centering = C_FACE;
}
if (laue == LAUE2M && centering == BODY) {
debug_print("Monocli I to C\n");
mat_copy_matrix_d3(correction_mat, monocli_i2c);
centering = C_FACE;
}
break;
case 3:
/* hP (a=b) but not hR (a=b=c) */
centering = R_CENTER;
mat_multiply_matrix_id3(trans_corr_mat, transform_mat, rhombo_obverse);
if (mat_is_int_matrix(trans_corr_mat, INT_PREC)) {
mat_copy_matrix_d3(correction_mat, rhombo_obverse);
debug_print("R-center observe setting\n");
debug_print_matrix_d3(trans_corr_mat);
}
mat_multiply_matrix_id3(trans_corr_mat, transform_mat, rhomb_reverse);
if (mat_is_int_matrix(trans_corr_mat, INT_PREC)) {
mat_copy_matrix_d3(correction_mat, rhomb_reverse);
debug_print("R-center reverse setting\n");
debug_print_matrix_d3(trans_corr_mat);
}
break;
case 4:
centering = FACE;
break;
default:
centering = CENTERING_ERROR;
break;
}
return centering;
}
static Centering get_base_center(SPGCONST int transform_mat[3][3])
{
int i;
Centering centering = PRIMITIVE;
debug_print("lat_get_base_center\n");
/* C center */
for (i = 0; i < 3; i++) {
if (transform_mat[i][0] == 0 &&
transform_mat[i][1] == 0 &&
abs(transform_mat[i][2]) == 1) {
centering = C_FACE;
goto end;
}
}
/* A center */
for (i = 0; i < 3; i++) {
if (abs(transform_mat[i][0]) == 1 &&
transform_mat[i][1] == 0 &&
transform_mat[i][2] == 0) {
centering = A_FACE;
goto end;
}
}
/* B center */
for (i = 0; i < 3; i++) {
if (transform_mat[i][0] == 0 &&
abs(transform_mat[i][1]) == 1 &&
transform_mat[i][2] == 0) {
centering = B_FACE;
goto end;
}
}
/* body center */
if ((abs(transform_mat[0][0]) +
abs(transform_mat[0][1]) +
abs(transform_mat[0][2]) == 2) &&
(abs(transform_mat[1][0]) +
abs(transform_mat[1][1]) +
abs(transform_mat[1][2]) == 2) &&
(abs(transform_mat[2][0]) +
abs(transform_mat[2][1]) +
abs(transform_mat[2][2]) == 2)) {
centering = BODY;
goto end;
}
/* This should not happen. */
warning_print("spglib: No centring was found (line %d, %s).\n", __LINE__, __FILE__);
return PRIMITIVE;
end:
return centering;
}
static int get_centering_shifts(double shift[3][3],
const Centering centering)
{
int i, j, multi;
multi = 1;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
shift[i][j] = 0;
}
}
if (centering != PRIMITIVE) {
if (centering != FACE && centering != R_CENTER) {
for (i = 0; i < 3; i++) { shift[0][i] = 0.5; } /* BASE */
if (centering == A_FACE) { shift[0][0] = 0; }
if (centering == B_FACE) { shift[0][1] = 0; }
if (centering == C_FACE) { shift[0][2] = 0; }
multi = 2;
}
if (centering == R_CENTER) {
shift[0][0] = 2. / 3;
shift[0][1] = 1. / 3;
shift[0][2] = 1. / 3;
shift[1][0] = 1. / 3;
shift[1][1] = 2. / 3;
shift[1][2] = 2. / 3;
multi = 3;
}
if (centering == FACE) {
shift[0][0] = 0;
shift[0][1] = 0.5;
shift[0][2] = 0.5;
shift[1][0] = 0.5;
shift[1][1] = 0;
shift[1][2] = 0.5;
shift[2][0] = 0.5;
shift[2][1] = 0.5;
shift[2][2] = 0;
multi = 4;
}
}
return multi;
}
Reference in New Issue View Git Blame Copy Permalink