Пример #1
0
static Spacegroup get_spacegroup(SPGCONST Cell * primitive,
                                 const double symprec)
{
    int hall_number;
    double conv_lattice[3][3];
    double origin_shift[3];
    Symmetry *symmetry;
    Spacegroup spacegroup;
    SpacegroupType spacegroup_type;

    symmetry = sym_get_operation(primitive, symprec);
    if (symmetry->size == 0) {
        spacegroup.number = 0;
        warning_print("spglib: Space group could not be found ");
        warning_print("(line %d, %s).\n", __LINE__, __FILE__);
        goto ret;
    }

    hall_number = get_hall_number(origin_shift,
                                  conv_lattice,
                                  primitive,
                                  symmetry,
                                  symprec);

    if (hall_number == 0) {
        spacegroup.number = 0;
        warning_print("spglib: Space group could not be found ");
        warning_print("(line %d, %s).\n", __LINE__, __FILE__);
        goto ret;
    }

    spacegroup_type = spgdb_get_spacegroup_type(hall_number);

    if (spacegroup_type.number > 0) {
        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.holohedry = spacegroup_type.holohedry;
        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);
    } else {
        spacegroup.number = 0;
        warning_print("spglib: Space group could not be found ");
        warning_print("(line %d, %s).\n", __LINE__, __FILE__);
    }

ret:
    /* spacegroup.number = 0 when space group was not found. */
    sym_free_symmetry(symmetry);
    return spacegroup;
}
Пример #2
0
/* 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.number = 0;
  spacegroup_type = spgdb_get_spacegroup_type(hall_number);

  if (spacegroup_type.number > 0) {
    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.setting,
	   spacegroup_type.setting);
  }

  return spacegroup;
}
Пример #3
0
static Centering get_centering(int hall_number)
{
  SpacegroupType spgtype;

  spgtype = spgdb_get_spacegroup_type(hall_number);

  return spgtype.centering;
}
Пример #4
0
/* Return spglibtype.number = 0 if failed */
SpglibSpacegroupType spg_get_spacegroup_type(const int hall_number)
{
  SpglibSpacegroupType spglibtype;
  SpacegroupType spgtype;

  spgtype = spgdb_get_spacegroup_type(hall_number);
  spglibtype.number = spgtype.number;
  strcpy(spglibtype.schoenflies, spgtype.schoenflies);
  strcpy(spglibtype.hall_symbol, spgtype.hall_symbol);
  strcpy(spglibtype.international, spgtype.international);
  strcpy(spglibtype.international_full, spgtype.international_full);
  strcpy(spglibtype.international_short, spgtype.international_short);
  
  return spglibtype;
}
Пример #5
0
/* Return NULL if failed */
static SpglibDataset * get_dataset(SPGCONST double lattice[3][3],
				   SPGCONST double position[][3],
				   const int types[],
				   const int num_atom,
				   const int hall_number,
				   const double symprec)
{
  Spacegroup spacegroup;
  SpacegroupType spacegroup_type;
  SpglibDataset *dataset;
  Cell *cell;
  Primitive *primitive;

  spacegroup.number = 0;
  dataset = NULL;
  cell = NULL;
  primitive = NULL;

  if ((dataset = (SpglibDataset*) malloc(sizeof(SpglibDataset))) == NULL) {
    warning_print("spglib: Memory could not be allocated.");
    return NULL;
  }

  dataset->spacegroup_number = 0;
  strcpy(dataset->international_symbol, "");
  strcpy(dataset->hall_symbol, "");
  strcpy(dataset->setting, "");
  dataset->origin_shift[0] = 0;
  dataset->origin_shift[1] = 0;
  dataset->origin_shift[2] = 0;
  dataset->n_atoms = 0;
  dataset->wyckoffs = NULL;
  dataset->equivalent_atoms = NULL;
  dataset->n_operations = 0;
  dataset->rotations = NULL;
  dataset->translations = NULL;
  dataset->n_brv_atoms = 0;
  dataset->brv_positions = NULL;
  dataset->brv_types = NULL;

  if ((cell = cel_alloc_cell(num_atom)) == NULL) {
    free(dataset);
    dataset = NULL;
    return NULL;
  }

  cel_set_cell(cell, lattice, position, types);

  primitive = spa_get_spacegroup(&spacegroup, cell, symprec);

  if ((spacegroup.number > 0) && (primitive != NULL)) {

    /* With hall_number > 0, specific choice is searched. */
    if (hall_number > 0) {
      spacegroup_type = spgdb_get_spacegroup_type(hall_number);
      if (spacegroup.number == spacegroup_type.number) {
	spacegroup = spa_get_spacegroup_with_hall_number(primitive,
							 hall_number);
      } else {
	goto err;
      }

      if (spacegroup.number == 0) {
	goto err;
      }
    }

    if (spacegroup.number > 0) {
      if ((set_dataset(dataset,
		       cell,
		       primitive->cell,
		       &spacegroup,
		       primitive->mapping_table,
		       primitive->tolerance)) == 0) {
	goto err;
      }
    }
  }

  cel_free_cell(cell);
  prm_free_primitive(primitive);

  return dataset;

 err:
  cel_free_cell(cell);
  prm_free_primitive(primitive);
  free(dataset);
  dataset = NULL;
  return NULL;
}
Пример #6
0
/* 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;
}