/* Each value of 'map' correspnds to the index of grid_point. */ int kpt_get_irreducible_reciprocal_mesh(int grid_address[][3], int map[], const int mesh[3], const int is_shift[3], const int is_time_reversal, const Symmetry * symmetry) { int i; PointSymmetry point_symmetry; MatINT *rotations; rotations = mat_alloc_MatINT(symmetry->size); for (i = 0; i < symmetry->size; i++) { mat_copy_matrix_i3(rotations->mat[i], symmetry->rot[i]); } point_symmetry = get_point_group_reciprocal(rotations, is_time_reversal); mat_free_MatINT(rotations); #ifdef _OPENMP return get_ir_reciprocal_mesh_openmp(grid_address, map, mesh, is_shift, &point_symmetry); #else return get_ir_reciprocal_mesh(grid_address, map, mesh, is_shift, &point_symmetry); #endif }
int spg_get_grid_points_by_rotations(int rot_grid_points[], const int address_orig[3], const int num_rot, SPGCONST int rot_reciprocal[][3][3], const int mesh[3], const int is_shift[3]) { int i; MatINT *rot; rot = NULL; if ((rot = mat_alloc_MatINT(num_rot)) == NULL) { return 0; } for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot->mat[i], rot_reciprocal[i]); } kpt_get_grid_points_by_rotations(rot_grid_points, address_orig, rot, mesh, is_shift); mat_free_MatINT(rot); return 1; }
static int extract_triplets_reciprocal_mesh_at_q(int triplets_at_q[][3], int weight_triplets_at_q[], const int fixed_grid_number, const int num_triplets, SPGCONST int triplets[][3], const int mesh[3], const int is_time_reversal, const int num_rot, SPGCONST int rotations[][3][3]) { MatINT *rot_real; int i, num_ir; rot_real = mat_alloc_MatINT(num_rot); for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot_real->mat[i], rotations[i]); } num_ir = kpt_extract_triplets_reciprocal_mesh_at_q(triplets_at_q, weight_triplets_at_q, fixed_grid_number, num_triplets, triplets, mesh, is_time_reversal, rot_real); mat_free_MatINT(rot_real); return num_ir; }
static int get_triplets_reciprocal_mesh_at_q(int map_triplets[], int map_q[], int grid_address[][3], const int grid_point, const int mesh[3], const int is_time_reversal, const int num_rot, SPGCONST int rotations[][3][3]) { MatINT *rot_real; int i, num_ir; rot_real = mat_alloc_MatINT(num_rot); for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot_real->mat[i], rotations[i]); } num_ir = kpt_get_ir_triplets_at_q(map_triplets, map_q, grid_address, grid_point, mesh, is_time_reversal, rot_real); mat_free_MatINT(rot_real); return num_ir; }
static int get_stabilized_reciprocal_mesh(int grid_address[][3], int map[], const int mesh[3], const int is_shift[3], const int is_time_reversal, const int num_rot, SPGCONST int rotations[][3][3], const int num_q, SPGCONST double qpoints[][3]) { MatINT *rot_real; int i, num_ir; rot_real = mat_alloc_MatINT(num_rot); for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot_real->mat[i], rotations[i]); } num_ir = kpt_get_stabilized_reciprocal_mesh(grid_address, map, mesh, is_shift, is_time_reversal, rot_real, num_q, qpoints); mat_free_MatINT(rot_real); return num_ir; }
/*---------*/ static int get_ir_reciprocal_mesh(int grid_address[][3], int map[], const int mesh[3], const int is_shift[3], const int is_time_reversal, SPGCONST double lattice[3][3], SPGCONST double position[][3], const int types[], const int num_atom, const double symprec) { SpglibDataset *dataset; int num_ir, i; MatINT *rotations; dataset = get_dataset(lattice, position, types, num_atom, symprec); rotations = mat_alloc_MatINT(dataset->n_operations); for (i = 0; i < dataset->n_operations; i++) { mat_copy_matrix_i3(rotations->mat[i], dataset->rotations[i]); } num_ir = kpt_get_irreducible_reciprocal_mesh(grid_address, map, mesh, is_shift, is_time_reversal, rotations); mat_free_MatINT(rotations); spg_free_dataset(dataset); return num_ir; }
static Symmetry * reduce_operation(SPGCONST Cell * cell, SPGCONST Symmetry * symmetry, const double symprec) { int i, j, num_sym; Symmetry * sym_reduced; PointSymmetry point_symmetry; MatINT *rot; VecDBL *trans; debug_print("reduce_operation:\n"); point_symmetry = get_lattice_symmetry(cell, symprec); rot = mat_alloc_MatINT(symmetry->size); trans = mat_alloc_VecDBL(symmetry->size); num_sym = 0; for (i = 0; i < point_symmetry.size; i++) { for (j = 0; j < symmetry->size; j++) { if (mat_check_identity_matrix_i3(point_symmetry.rot[i], symmetry->rot[j])) { if (is_overlap_all_atoms(symmetry->trans[j], symmetry->rot[j], cell, symprec, 0)) { mat_copy_matrix_i3(rot->mat[num_sym], symmetry->rot[j]); mat_copy_vector_d3(trans->vec[num_sym], symmetry->trans[j]); num_sym++; } } } } sym_reduced = sym_alloc_symmetry(num_sym); for (i = 0; i < num_sym; i++) { mat_copy_matrix_i3(sym_reduced->rot[i], rot->mat[i]); mat_copy_vector_d3(sym_reduced->trans[i], trans->vec[i]); } mat_free_MatINT(rot); mat_free_VecDBL(trans); debug_print(" num_sym %d -> %d\n", symmetry->size, num_sym); return sym_reduced; }
static MatINT *get_point_group_reciprocal_with_q(const MatINT * rot_reciprocal, const double symprec, const int num_q, SPGCONST double qpoints[][3]) { int i, j, k, l, is_all_ok, num_rot; int *ir_rot; double q_rot[3], diff[3]; MatINT * rot_reciprocal_q; is_all_ok = 0; num_rot = 0; ir_rot = (int*)malloc(sizeof(int) * rot_reciprocal->size); for (i = 0; i < rot_reciprocal->size; i++) { ir_rot[i] = -1; } for (i = 0; i < rot_reciprocal->size; i++) { for (j = 0; j < num_q; j++) { is_all_ok = 0; mat_multiply_matrix_vector_id3(q_rot, rot_reciprocal->mat[i], qpoints[j]); for (k = 0; k < num_q; k++) { for (l = 0; l < 3; l++) { diff[l] = q_rot[l] - qpoints[k][l]; diff[l] -= mat_Nint(diff[l]); } if (mat_Dabs(diff[0]) < symprec && mat_Dabs(diff[1]) < symprec && mat_Dabs(diff[2]) < symprec) { is_all_ok = 1; break; } } if (! is_all_ok) { break; } } if (is_all_ok) { ir_rot[num_rot] = i; num_rot++; } } rot_reciprocal_q = mat_alloc_MatINT(num_rot); for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot_reciprocal_q->mat[i], rot_reciprocal->mat[ir_rot[i]]); } free(ir_rot); return rot_reciprocal_q; }
static void get_proper_rotation(int prop_rot[3][3], SPGCONST int rot[3][3]) { if (mat_get_determinant_i3(rot) == -1) { mat_multiply_matrix_i3(prop_rot, inversion, rot); } else { mat_copy_matrix_i3(prop_rot, rot); } }
/* pointgroup is modified. */ void ptg_get_transformation_matrix( Pointgroup * pointgroup, const Symmetry * symmetry ) { int axes[3]; int transform_mat[3][3]; get_axes( axes, pointgroup->laue, symmetry ); get_transform_matrix( transform_mat, axes ); mat_copy_matrix_i3( pointgroup->transform_mat, transform_mat ); }
static PointSymmetry get_lattice_symmetry(SPGCONST Cell *cell, const double symprec) { int i, j, k, num_sym; int axes[3][3]; double lattice[3][3], min_lattice[3][3]; double metric[3][3], metric_orig[3][3]; PointSymmetry lattice_sym; debug_print("get_lattice_symmetry:\n"); if (! lat_smallest_lattice_vector(min_lattice, cell->lattice, symprec)) { goto err; } mat_get_metric(metric_orig, min_lattice); num_sym = 0; for (i = 0; i < 26; i++) { for (j = 0; j < 26; j++) { for (k = 0; k < 26; k++) { set_axes(axes, i, j, k); if (! ((mat_get_determinant_i3(axes) == 1) || (mat_get_determinant_i3(axes) == -1))) { continue; } mat_multiply_matrix_di3(lattice, min_lattice, axes); mat_get_metric(metric, lattice); if (is_identity_metric(metric, metric_orig, symprec)) { mat_copy_matrix_i3(lattice_sym.rot[num_sym], axes); num_sym++; } if (num_sym > 48) { warning_print("spglib: Too many lattice symmetries was found.\n"); warning_print(" Tolerance may be too large "); warning_print("(line %d, %s).\n", __LINE__, __FILE__); goto err; } } } } lattice_sym.size = num_sym; return transform_pointsymmetry(&lattice_sym, cell->lattice, min_lattice); err: lattice_sym.size = 0; return lattice_sym; }
static MatINT *get_point_group_reciprocal(const MatINT * rotations, const int is_time_reversal) { int i, j, num_rot; MatINT *rot_reciprocal, *rot_return; int *unique_rot; SPGCONST int inversion[3][3] = { {-1, 0, 0 }, { 0,-1, 0 }, { 0, 0,-1 } }; if (is_time_reversal) { rot_reciprocal = mat_alloc_MatINT(rotations->size * 2); } else { rot_reciprocal = mat_alloc_MatINT(rotations->size); } unique_rot = (int*)malloc(sizeof(int) * rot_reciprocal->size); for (i = 0; i < rot_reciprocal->size; i++) { unique_rot[i] = -1; } for (i = 0; i < rotations->size; i++) { mat_transpose_matrix_i3(rot_reciprocal->mat[i], rotations->mat[i]); if (is_time_reversal) { mat_multiply_matrix_i3(rot_reciprocal->mat[rotations->size+i], inversion, rot_reciprocal->mat[i]); } } num_rot = 0; for (i = 0; i < rot_reciprocal->size; i++) { for (j = 0; j < num_rot; j++) { if (mat_check_identity_matrix_i3(rot_reciprocal->mat[unique_rot[j]], rot_reciprocal->mat[i])) { goto escape; } } unique_rot[num_rot] = i; num_rot++; escape: ; } rot_return = mat_alloc_MatINT(num_rot); for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot_return->mat[i], rot_reciprocal->mat[unique_rot[i]]); } free(unique_rot); mat_free_MatINT(rot_reciprocal); return rot_return; }
static void set_dataset(SpglibDataset * dataset, SPGCONST Cell * cell, SPGCONST Cell * primitive, SPGCONST Spacegroup * spacegroup, const int * mapping_table, const double tolerance) { int i; double inv_mat[3][3]; Cell *bravais; Symmetry *symmetry; /* 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_mat, cell->lattice, tolerance); mat_multiply_matrix_d3(dataset->transformation_matrix, inv_mat, spacegroup->bravais_lattice); mat_copy_vector_d3(dataset->origin_shift, spacegroup->origin_shift); /* Symmetry operations */ symmetry = ref_get_refined_symmetry_operations(cell, primitive, spacegroup, tolerance); dataset->rotations = (int (*)[3][3])malloc(sizeof(int[3][3]) * symmetry->size); dataset->translations = (double (*)[3])malloc(sizeof(double[3]) * symmetry->size); dataset->n_operations = symmetry->size; 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 */ dataset->wyckoffs = (int*) malloc(sizeof(int) * cell->size); dataset->equivalent_atoms = (int*) malloc(sizeof(int) * cell->size); bravais = ref_get_Wyckoff_positions(dataset->wyckoffs, dataset->equivalent_atoms, primitive, cell, spacegroup, symmetry, mapping_table, tolerance); cel_free_cell(bravais); sym_free_symmetry(symmetry); }
void mat_multiply_matrix_i3(int m[3][3], const int a[3][3], const int b[3][3]) { int i, j; /* a_ij */ int c[3][3]; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j]; } } mat_copy_matrix_i3(m, c); }
static Symmetry * get_primitive_db_symmetry(SPGCONST double t_mat[3][3], const Symmetry *conv_sym, const double symprec) { int i, j, num_op; double inv_mat[3][3], tmp_mat[3][3]; MatINT *r_prim; VecDBL *t_prim; Symmetry *prim_sym; r_prim = mat_alloc_MatINT(conv_sym->size); t_prim = mat_alloc_VecDBL(conv_sym->size); mat_inverse_matrix_d3(inv_mat, t_mat, symprec); num_op = 0; for (i = 0; i < conv_sym->size; i++) { for (j = 0; j < i; j++) { if (mat_check_identity_matrix_i3(conv_sym->rot[i], conv_sym->rot[j])) { goto pass; } } /* R' = T*R*T^-1 */ mat_multiply_matrix_di3(tmp_mat, t_mat, conv_sym->rot[i]); mat_multiply_matrix_d3(tmp_mat, tmp_mat, inv_mat); mat_cast_matrix_3d_to_3i(r_prim->mat[ num_op ], tmp_mat); /* t' = T*t */ mat_multiply_matrix_vector_d3(t_prim->vec[ num_op ], t_mat, conv_sym->trans[ i ]); num_op++; pass: ; } prim_sym = sym_alloc_symmetry(num_op); for (i = 0; i < num_op; i++) { mat_copy_matrix_i3(prim_sym->rot[i], r_prim->mat[i]); for (j = 0; j < 3; j++) { prim_sym->trans[i][j] = t_prim->vec[i][j] - mat_Nint(t_prim->vec[i][j]); } } mat_free_MatINT(r_prim); mat_free_VecDBL(t_prim); return prim_sym; }
SpglibTriplets * spg_get_triplets_reciprocal_mesh( const int mesh[3], const int is_time_reversal, SPGCONST double lattice[3][3], const int num_rot, SPGCONST int rotations[][3][3], const double symprec ) { int i, j, num_grid; MatINT *rot_real; Triplets *tps; SpglibTriplets *spg_triplets; num_grid = mesh[0] * mesh[1] * mesh[2]; rot_real = mat_alloc_MatINT( num_rot ); for ( i = 0; i < num_rot; i++ ) { mat_copy_matrix_i3( rot_real->mat[i], rotations[i] ); } tps = kpt_get_triplets_reciprocal_mesh( mesh, is_time_reversal, lattice, rot_real, symprec ); mat_free_MatINT( rot_real ); spg_triplets = (SpglibTriplets*) malloc( sizeof( SpglibTriplets ) ); spg_triplets->size = tps->size; spg_triplets->triplets = (int (*)[3]) malloc( sizeof(int[3]) * tps->size ); spg_triplets->weights = (int*) malloc( sizeof(int) * tps->size ); spg_triplets->mesh_points = (int (*)[3]) malloc( sizeof(int[3]) * num_grid ); for ( i = 0; i < 3; i++ ) { spg_triplets->mesh[i] = tps->mesh[i]; } for ( i = 0; i < num_grid; i++ ) { for ( j = 0; j < 3; j++ ) { spg_triplets->mesh_points[i][j] = tps->mesh_points[i][j]; } } for ( i = 0; i < tps->size; i++ ) { for ( j = 0; j < 3; j++ ) { spg_triplets->triplets[i][j] = tps->triplets[i][j]; } spg_triplets->weights[i] = tps->weights[i]; } kpt_free_triplets( tps ); return spg_triplets; }
int spg_get_symmetry_from_database(int rotations[192][3][3], double translations[192][3], const int hall_number) { int i; Symmetry *symmetry; symmetry = spgdb_get_spacegroup_operations(hall_number); for (i = 0; i < symmetry->size; i++) { mat_copy_matrix_i3(rotations[i], symmetry->rot[i]); mat_copy_vector_d3(translations[i], symmetry->trans[i]); } return symmetry->size; }
/* num_q is the number of the qpoints. */ static PointSymmetry get_point_group_reciprocal(const MatINT * rotations, const int is_time_reversal) { int i, j, num_pt = 0; MatINT *rot_reciprocal; PointSymmetry point_symmetry; SPGCONST int inversion[3][3] = { {-1, 0, 0 }, { 0,-1, 0 }, { 0, 0,-1 } }; if (is_time_reversal) { rot_reciprocal = mat_alloc_MatINT(rotations->size * 2); } else { rot_reciprocal = mat_alloc_MatINT(rotations->size); } for (i = 0; i < rotations->size; i++) { mat_transpose_matrix_i3(rot_reciprocal->mat[i], rotations->mat[i]); if (is_time_reversal) { mat_multiply_matrix_i3(rot_reciprocal->mat[rotations->size+i], inversion, rot_reciprocal->mat[i]); } } for (i = 0; i < rot_reciprocal->size; i++) { for (j = 0; j < num_pt; j++) { if (mat_check_identity_matrix_i3(point_symmetry.rot[j], rot_reciprocal->mat[i])) { goto escape; } } mat_copy_matrix_i3(point_symmetry.rot[num_pt], rot_reciprocal->mat[i]); num_pt++; escape: ; } point_symmetry.size = num_pt; mat_free_MatINT(rot_reciprocal); return point_symmetry; }
void mat_transpose_matrix_i3(int a[3][3], const int b[3][3]) { int c[3][3]; c[0][0] = b[0][0]; c[0][1] = b[1][0]; c[0][2] = b[2][0]; c[1][0] = b[0][1]; c[1][1] = b[1][1]; c[1][2] = b[2][1]; c[2][0] = b[0][2]; c[2][1] = b[1][2]; c[2][2] = b[2][2]; mat_copy_matrix_i3(a, c); }
/* Return NULL if failed */ VecDBL * sym_reduce_pure_translation(SPGCONST Cell * cell, const VecDBL * pure_trans, const double symprec) { int i, multi; Symmetry *symmetry, *symmetry_reduced; VecDBL * pure_trans_reduced; symmetry = NULL; symmetry_reduced = NULL; pure_trans_reduced = NULL; multi = pure_trans->size; if ((symmetry = sym_alloc_symmetry(multi)) == NULL) { return NULL; } for (i = 0; i < multi; i++) { mat_copy_matrix_i3(symmetry->rot[i], identity); mat_copy_vector_d3(symmetry->trans[i], pure_trans->vec[i]); } if ((symmetry_reduced = reduce_operation(cell, symmetry, symprec, angle_tolerance)) == NULL) { sym_free_symmetry(symmetry); symmetry = NULL; return NULL; } sym_free_symmetry(symmetry); symmetry = NULL; multi = symmetry_reduced->size; if ((pure_trans_reduced = mat_alloc_VecDBL(multi)) == NULL) { sym_free_symmetry(symmetry_reduced); symmetry_reduced = NULL; return NULL; } for (i = 0; i < multi; i++) { mat_copy_vector_d3(pure_trans_reduced->vec[i], symmetry_reduced->trans[i]); } sym_free_symmetry(symmetry_reduced); symmetry_reduced = NULL; return pure_trans_reduced; }
/* Return 0 if failed */ static int get_symmetry_numerical(int rotation[][3][3], double translation[][3], const int max_size, SPGCONST double lattice[3][3], SPGCONST double position[][3], const int types[], const int num_atom, const double symprec) { int i, size; Cell *cell; Symmetry *symmetry; size = 0; cell = NULL; symmetry = NULL; if ((cell = cel_alloc_cell(num_atom)) == NULL) { return 0; } cel_set_cell(cell, lattice, position, types); if ((symmetry = sym_get_operation(cell, symprec)) == NULL) { cel_free_cell(cell); return 0; } if (symmetry->size > max_size) { fprintf(stderr, "spglib: Indicated max size(=%d) is less than number ", max_size); fprintf(stderr, "spglib: of symmetry operations(=%d).\n", symmetry->size); goto ret; } for (i = 0; i < symmetry->size; i++) { mat_copy_matrix_i3(rotation[i], symmetry->rot[i]); mat_copy_vector_d3(translation[i], symmetry->trans[i]); } size = symmetry->size; ret: sym_free_symmetry(symmetry); cel_free_cell(cell); return size; }
static PointSymmetry get_point_group_reciprocal_with_q(SPGCONST PointSymmetry * pointgroup, const double symprec, const int num_q, SPGCONST double qpoints[][3]) { int i, j, k, l, is_all_ok=0, num_ptq = 0; double q_rot[3], diff[3]; PointSymmetry pointgroup_q; for (i = 0; i < pointgroup->size; i++) { for (j = 0; j < num_q; j++) { is_all_ok = 0; mat_multiply_matrix_vector_id3(q_rot, pointgroup->rot[i], qpoints[j]); for (k = 0; k < num_q; k++) { for (l = 0; l < 3; l++) { diff[l] = q_rot[l] - qpoints[k][l]; diff[l] -= mat_Nint(diff[l]); } if (mat_Dabs(diff[0]) < symprec && mat_Dabs(diff[1]) < symprec && mat_Dabs(diff[2]) < symprec) { is_all_ok = 1; break; } } if (! is_all_ok) { break; } } if (is_all_ok) { mat_copy_matrix_i3(pointgroup_q.rot[num_ptq], pointgroup->rot[i]); num_ptq++; } } pointgroup_q.size = num_ptq; return pointgroup_q; }
static void set_translation_with_origin_shift(Symmetry *conv_sym, const double origin_shift[3]) { int i, j; double tmp_vec[3]; int tmp_mat[3][3]; /* t' = t - (R-E)w, w is the origin shift */ for (i = 0; i < conv_sym->size; i++) { mat_copy_matrix_i3(tmp_mat, conv_sym->rot[i]); tmp_mat[0][0]--; tmp_mat[1][1]--; tmp_mat[2][2]--; mat_multiply_matrix_vector_id3(tmp_vec, tmp_mat, origin_shift); for (j = 0; j < 3; j++) { conv_sym->trans[i][j] -= tmp_vec[j]; } } }
/* Return 0 if failed */ static int get_symmetry_from_dataset(int rotation[][3][3], double translation[][3], const int max_size, SPGCONST double lattice[3][3], SPGCONST double position[][3], const int types[], const int num_atom, const double symprec) { int i, num_sym; SpglibDataset *dataset; num_sym = 0; dataset = NULL; if ((dataset = get_dataset(lattice, position, types, num_atom, 0, symprec)) == NULL) { return 0; } if (dataset->n_operations > max_size) { fprintf(stderr, "spglib: Indicated max size(=%d) is less than number ", max_size); fprintf(stderr, "spglib: of symmetry operations(=%d).\n", dataset->n_operations); goto ret; } num_sym = dataset->n_operations; for (i = 0; i < num_sym; i++) { mat_copy_matrix_i3(rotation[i], dataset->rotations[i]); mat_copy_vector_d3(translation[i], dataset->translations[i]); } ret: spg_free_dataset(dataset); return num_sym; }
static Symmetry * get_db_symmetry(const int hall_number) { int i; int operation_index[2]; int rot[3][3]; double trans[3]; Symmetry *symmetry; spgdb_get_operation_index(operation_index, hall_number); symmetry = sym_alloc_symmetry(operation_index[0]); for (i = 0; i < operation_index[0]; i++) { /* rotation matrix matching and set difference of translations */ spgdb_get_operation(rot, trans, operation_index[1] + i); mat_copy_matrix_i3(symmetry->rot[i], rot); mat_copy_vector_d3(symmetry->trans[i], trans); } return symmetry; }
static PointSymmetry get_pointsymmetry(SPGCONST int rotations[][3][3], const int num_rotations) { int i, j; PointSymmetry pointsym; pointsym.size = 0; for (i = 0; i < num_rotations; i++) { for (j = 0; j < pointsym.size; j++) { if (mat_check_identity_matrix_i3(rotations[i], pointsym.rot[j])) { goto escape; } } mat_copy_matrix_i3(pointsym.rot[pointsym.size], rotations[i]); pointsym.size++; escape: ; } return pointsym; }
static int get_symmetry_with_collinear_spin(int rotation[][3][3], double translation[][3], const int max_size, SPGCONST double lattice[3][3], SPGCONST double position[][3], const int types[], const double spins[], const int num_atom, const double symprec) { int i, j, size; Symmetry *symmetry; Cell *cell; cell = cel_alloc_cell(num_atom); cel_set_cell(cell, lattice, position, types); symmetry = spn_get_collinear_operation(cell, spins, symprec); if (symmetry->size > max_size) { fprintf(stderr, "spglib: Indicated max size(=%d) is less than number ", max_size); fprintf(stderr, "spglib: of symmetry operations(=%d).\n", symmetry->size); sym_free_symmetry(symmetry); return 0; } for (i = 0; i < symmetry->size; i++) { mat_copy_matrix_i3(rotation[i], symmetry->rot[i]); for (j = 0; j < 3; j++) { translation[i][j] = symmetry->trans[i][j]; } } size = symmetry->size; cel_free_cell(cell); sym_free_symmetry(symmetry); return size; }
int kpt_get_irreducible_kpoints(int map[], SPGCONST double kpoints[][3], const int num_kpoint, const Symmetry * symmetry, const int is_time_reversal, const double symprec) { int i; PointSymmetry point_symmetry; MatINT *rotations; rotations = mat_alloc_MatINT(symmetry->size); for (i = 0; i < symmetry->size; i++) { mat_copy_matrix_i3(rotations->mat[i], symmetry->rot[i]); } point_symmetry = get_point_group_reciprocal(rotations, is_time_reversal); mat_free_MatINT(rotations); return get_ir_kpoints(map, kpoints, num_kpoint, &point_symmetry, symprec); }
/* Return 0 if failed */ int spg_get_symmetry_from_database(int rotations[192][3][3], double translations[192][3], const int hall_number) { int i, size; Symmetry *symmetry; symmetry = NULL; if ((symmetry = spgdb_get_spacegroup_operations(hall_number)) == NULL) { return 0; } for (i = 0; i < symmetry->size; i++) { mat_copy_matrix_i3(rotations[i], symmetry->rot[i]); mat_copy_vector_d3(translations[i], symmetry->trans[i]); } size = symmetry->size; sym_free_symmetry(symmetry); return size; }
void spg_get_BZ_grid_points_by_rotations(int rot_grid_points[], const int address_orig[3], const int num_rot, SPGCONST int rot_reciprocal[][3][3], const int mesh[3], const int is_shift[3], const int bz_map[]) { int i; MatINT *rot; rot = mat_alloc_MatINT(num_rot); for (i = 0; i < num_rot; i++) { mat_copy_matrix_i3(rot->mat[i], rot_reciprocal[i]); } kpt_get_BZ_grid_points_by_rotations(rot_grid_points, address_orig, rot, mesh, is_shift, bz_map); mat_free_MatINT(rot); }