Pointgroup ptg_get_transformation_matrix(int transform_mat[3][3],
SPGCONST int rotations[][3][3],
const int num_rotations)
{
int i, j, pg_num;
int axes[3];
PointSymmetry pointsym;
Pointgroup pointgroup;
debug_print("ptg_get_transformation_matrix:\n");
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
transform_mat[i][j] = 0;
}
}
pg_num = get_pointgroup_number_by_rotations(rotations, num_rotations);
if (pg_num > 0) {
pointgroup = ptg_get_pointgroup(pg_num);
pointsym = get_pointsymmetry(rotations, num_rotations);
get_axes(axes, pointgroup.laue, &pointsym);
set_transformation_matrix(transform_mat, axes);
} else {
pointgroup = ptg_get_pointgroup(0);
}
return pointgroup;
}
static Centering get_transformation_matrix( double trans_mat[3][3],
SPGCONST Symmetry * symmetry )
{
int pg_num;
double correction_mat[3][3];
Centering centering;
Pointgroup pointgroup;
pg_num = ptg_get_pointgroup_number( symmetry );
pointgroup = ptg_get_pointgroup( pg_num );
ptg_get_transformation_matrix( &pointgroup, symmetry );
/* Centering is not determined only from symmetry operations */
/* sometimes. Therefore centering and transformation matrix are */
/* related. */
centering = lat_get_centering( correction_mat,
pointgroup.transform_mat,
pointgroup.laue );
mat_multiply_matrix_id3( trans_mat,
pointgroup.transform_mat,
correction_mat );
debug_print("correction matrix\n");
debug_print_matrix_d3( correction_mat );
return centering;
}
static void get_conventional_lattice(double lattice[3][3],
SPGCONST Spacegroup *spacegroup)
{
int i, j;
double metric[3][3];
Pointgroup pointgroup;
pointgroup = ptg_get_pointgroup(spacegroup->pointgroup_number);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
lattice[i][j] = 0;
}
}
mat_get_metric(metric, spacegroup->bravais_lattice);
debug_print("bravais lattice\n");
debug_print_matrix_d3(spacegroup->bravais_lattice);
debug_print("%s\n", spacegroup->setting);
switch (pointgroup.holohedry) {
case TRICLI:
set_tricli(lattice, metric);
break;
case MONOCLI: /* b-axis is the unique axis. */
set_monocli(lattice, metric);
break;
case ORTHO:
set_ortho(lattice, metric);
break;
case TETRA:
set_tetra(lattice, metric);
break;
case TRIGO:
if (spacegroup->setting[0] == 'R') {
set_rhomb(lattice, metric);
} else {
set_trigo(lattice, metric);
}
break;
case HEXA:
set_trigo(lattice, metric);
break;
case CUBIC:
set_cubic(lattice, metric);
break;
case HOLOHEDRY_NONE:
break;
}
}
int spg_get_pointgroup(char symbol[6],
int trans_mat[3][3],
SPGCONST int rotations[][3][3],
const int num_rotations)
{
int ptg_num;
double tmp_trans_mat[3][3];
Pointgroup ptgroup;
ptg_num = ptg_get_pointgroup_number_by_rotations(rotations,
num_rotations);
ptgroup = ptg_get_pointgroup(ptg_num);
strcpy(symbol, ptgroup.symbol);
ptg_get_transformation_matrix(tmp_trans_mat,
rotations,
num_rotations);
mat_cast_matrix_3d_to_3i(trans_mat, tmp_trans_mat);
return ptg_num + 1;
}
/* Return 0 if failed */
static int set_dataset(SpglibDataset * dataset,
SPGCONST Cell * cell,
SPGCONST Cell * primitive,
SPGCONST Spacegroup * spacegroup,
const int * mapping_table,
const double tolerance)
{
int i;
double inv_lat[3][3];
Cell *bravais;
Symmetry *symmetry;
Pointgroup pointgroup;
bravais = NULL;
symmetry = NULL;
/* Spacegroup type, transformation matrix, origin shift */
dataset->n_atoms = cell->size;
dataset->spacegroup_number = spacegroup->number;
dataset->hall_number = spacegroup->hall_number;
strcpy(dataset->international_symbol, spacegroup->international_short);
strcpy(dataset->hall_symbol, spacegroup->hall_symbol);
strcpy(dataset->setting, spacegroup->setting);
mat_inverse_matrix_d3(inv_lat, spacegroup->bravais_lattice, 0);
mat_multiply_matrix_d3(dataset->transformation_matrix,
inv_lat,
cell->lattice);
mat_copy_vector_d3(dataset->origin_shift, spacegroup->origin_shift);
/* Symmetry operations */
if ((symmetry = ref_get_refined_symmetry_operations(cell,
primitive,
spacegroup,
tolerance)) == NULL) {
return 0;
}
dataset->n_operations = symmetry->size;
if ((dataset->rotations =
(int (*)[3][3]) malloc(sizeof(int[3][3]) * dataset->n_operations))
== NULL) {
warning_print("spglib: Memory could not be allocated.");
goto err;
}
if ((dataset->translations =
(double (*)[3]) malloc(sizeof(double[3]) * dataset->n_operations))
== NULL) {
warning_print("spglib: Memory could not be allocated.");
goto err;
}
for (i = 0; i < symmetry->size; i++) {
mat_copy_matrix_i3(dataset->rotations[i], symmetry->rot[i]);
mat_copy_vector_d3(dataset->translations[i], symmetry->trans[i]);
}
/* Wyckoff positions */
if ((dataset->wyckoffs = (int*) malloc(sizeof(int) * dataset->n_atoms))
== NULL) {
warning_print("spglib: Memory could not be allocated.");
goto err;
}
if ((dataset->equivalent_atoms =
(int*) malloc(sizeof(int) * dataset->n_atoms))
== NULL) {
warning_print("spglib: Memory could not be allocated.");
goto err;
}
if ((bravais = ref_get_Wyckoff_positions(dataset->wyckoffs,
dataset->equivalent_atoms,
primitive,
cell,
spacegroup,
symmetry,
mapping_table,
tolerance)) == NULL) {
goto err;
}
dataset->n_std_atoms = bravais->size;
mat_copy_matrix_d3(dataset->std_lattice, bravais->lattice);
if ((dataset->std_positions =
(double (*)[3]) malloc(sizeof(double[3]) * dataset->n_std_atoms))
== NULL) {
warning_print("spglib: Memory could not be allocated.");
goto err;
}
if ((dataset->std_types = (int*) malloc(sizeof(int) * dataset->n_std_atoms))
== NULL) {
warning_print("spglib: Memory could not be allocated.");
goto err;
}
for (i = 0; i < dataset->n_std_atoms; i++) {
mat_copy_vector_d3(dataset->std_positions[i], bravais->position[i]);
dataset->std_types[i] = bravais->types[i];
}
cel_free_cell(bravais);
sym_free_symmetry(symmetry);
dataset->pointgroup_number = spacegroup->pointgroup_number;
pointgroup = ptg_get_pointgroup(spacegroup->pointgroup_number);
strcpy(dataset->pointgroup_symbol, pointgroup.symbol);
return 1;
err:
if (dataset->std_positions != NULL) {
free(dataset->std_positions);
dataset->std_positions = NULL;
}
if (bravais != NULL) {
cel_free_cell(bravais);
}
if (dataset->equivalent_atoms != NULL) {
free(dataset->equivalent_atoms);
dataset->equivalent_atoms = NULL;
}
if (dataset->wyckoffs != NULL) {
free(dataset->wyckoffs);
dataset->wyckoffs = NULL;
}
if (dataset->translations != NULL) {
free(dataset->translations);
dataset->translations = NULL;
}
if (dataset->rotations != NULL) {
free(dataset->rotations);
dataset->rotations = NULL;
}
if (symmetry != NULL) {
sym_free_symmetry(symmetry);
}
return 0;
}
