コード例 #1
0
ファイル: spacegroup.c プロジェクト: alexurba/cftb
static int get_hall_number_local( double origin_shift[3],
				  double conv_lattice[3][3],
				  Centering * centering,
				  SPGCONST Cell * primitive,
				  SPGCONST Symmetry * symmetry,
				  const double symprec )
{
  int hall_number;
  double trans_mat[3][3];
  Symmetry * conv_symmetry;

  *centering = get_transformation_matrix( trans_mat, symmetry );
  mat_multiply_matrix_d3( conv_lattice,
			  primitive->lattice,
			  trans_mat );
  conv_symmetry = get_conventional_symmetry( trans_mat,
					     *centering,
					     symmetry );

  hall_number = hal_get_hall_symbol( origin_shift,
				     *centering,
				     conv_lattice,
				     conv_symmetry,
				     symprec );
  sym_free_symmetry( conv_symmetry );

  return hall_number;
}
コード例 #2
0
ファイル: spacegroup.c プロジェクト: kassali-kamel/spglib
Symmetry * spa_get_conventional_symmetry(SPGCONST double transform_mat[3][3],
        const Centering centering,
        const Symmetry *primitive_sym)
{
    return get_conventional_symmetry(transform_mat,
                                     centering,
                                     primitive_sym);
}
コード例 #3
0
ファイル: spacegroup.c プロジェクト: WeiLiPenguin/pymatgen
/* Return NULL if failed */
static Symmetry *
get_initial_conventional_symmetry(const Centering centering,
				  SPGCONST double transform_mat[3][3],
				  SPGCONST 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;
}
コード例 #4
0
ファイル: spacegroup.c プロジェクト: WeiLiPenguin/pymatgen
/* 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,
					SPGCONST Symmetry *symmetry,
					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 < 18; i++) {
    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]);

    /* Choose |a| < |b| < |c| if there are freedom. */
    if (num_hall_types == 3) {
      l = 0;
      for (j = 0; j < 3; j++) {
	if (j == change_of_unique_axis_monocli[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 ((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;
}
コード例 #5
0
ファイル: spacegroup.c プロジェクト: WeiLiPenguin/pymatgen
/* 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,
				SPGCONST 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;
	}
      }
    }
    /* 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;
}