ConventionalCell.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
/* File: ConventionalCell.cpp */
 
#include <algorithm>
#include <cstdio>
#include <stdexcept>
 
#include "MantidGeometry/Crystal/ConventionalCell.h"
#include "MantidGeometry/Crystal/IndexingUtils.h"
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidKernel/V3D.h"
 
namespace Mantid::Geometry {
using Mantid::Kernel::DblMatrix;
using Mantid::Kernel::V3D;
 
ConventionalCell::ConventionalCell(const Kernel::DblMatrix &UB, size_t form_num, bool allowPermutations) {
  form_number = form_num;
  std::vector<double> lat_par;
  IndexingUtils::GetLatticeParameters(UB, lat_par);
 
  ReducedCell form_0 = ReducedCell(0, lat_par[0], lat_par[1], lat_par[2], lat_par[3], lat_par[4], lat_par[5]);
  ReducedCell form_i = ReducedCell(form_num, lat_par[0], lat_par[1], lat_par[2], lat_par[3], lat_par[4], lat_par[5]);
  init(UB, form_0, form_i, allowPermutations);
}
 
size_t ConventionalCell::GetFormNum() const { return form_number; }
 
double ConventionalCell::GetError() const { return scalars_error; }
 
std::string ConventionalCell::GetCellType() const { return std::string(cell_type); }
 
std::string ConventionalCell::GetCentering() const { return std::string(centering); }
 
Kernel::DblMatrix ConventionalCell::GetOriginalUB() const { return Kernel::DblMatrix(original_UB); }
 
Kernel::DblMatrix ConventionalCell::GetNewUB() const { return Kernel::DblMatrix(adjusted_UB); }
 
Kernel::DblMatrix ConventionalCell::GetHKL_Tran() const { return Kernel::DblMatrix(hkl_tran); }
 
double ConventionalCell::GetSumOfSides() const {
  std::vector<double> lat_par;
  IndexingUtils::GetLatticeParameters(adjusted_UB, lat_par);
  return lat_par[0] + lat_par[1] + lat_par[2];
}
 
std::string ConventionalCell::GetDescription() const {
  char buffer[100];
  sprintf(buffer, std::string("Form #%2d").c_str(), GetFormNum());
  std::string message(buffer);
 
  sprintf(buffer, std::string("  Error:%7.4f").c_str(), GetError());
  message += std::string(buffer);
 
  sprintf(buffer, std::string("  %-12s").c_str(), GetCellType().c_str());
  message += std::string(buffer);
 
  sprintf(buffer, std::string("  %1s  ").c_str(), GetCentering().c_str());
  message += std::string(buffer);
 
  return message;
}
 
void ConventionalCell::init(const Kernel::DblMatrix &UB, const ReducedCell &form_0, ReducedCell &form_i,
                            const bool allowPermutations) {
  scalars_error = form_0.WeightedDistance(form_i);
  cell_type = form_i.GetCellType();
  centering = form_i.GetCentering();
 
  original_UB = Kernel::DblMatrix(UB);
 
  hkl_tran = form_i.GetTransformation();
 
  Kernel::DblMatrix UB_tran(hkl_tran);
  UB_tran.Invert();
  adjusted_UB = UB * UB_tran;
  if (allowPermutations) {
    if (cell_type == ReducedCell::TETRAGONAL()) {
      StandardizeTetragonal(adjusted_UB);
    } else if (cell_type == ReducedCell::HEXAGONAL() || cell_type == ReducedCell::RHOMBOHEDRAL()) {
      StandardizeHexagonal(adjusted_UB);
    }
  }
}
 
void ConventionalCell::SetSidesIncreasing(Kernel::DblMatrix &UB) {
 
  std::vector<V3D> edges(3, V3D());
  OrientedLattice::GetABC(UB, edges[0], edges[1], edges[2]);
 
  std::sort(edges.begin(), edges.end(), V3D::compareMagnitude);
 
  V3D a = edges[0];
  V3D b = edges[1];
  V3D c = edges[2];
 
  V3D acrossb = a.cross_prod(b); // keep a,b,c right handed
  if (acrossb.scalar_prod(c) < 0) {
    c = c * (-1);
  }
  OrientedLattice::GetUB(UB, a, b, c);
}
 
void ConventionalCell::StandardizeTetragonal(Kernel::DblMatrix &UB) {
  V3D a;
  V3D b;
  V3D c;
  OrientedLattice::GetABC(UB, a, b, c);
 
  double a_b_diff = fabs(a.norm() - b.norm()) / std::min(a.norm(), b.norm());
 
  double a_c_diff = fabs(a.norm() - c.norm()) / std::min(a.norm(), c.norm());
 
  double b_c_diff = fabs(b.norm() - c.norm()) / std::min(b.norm(), c.norm());
 
  // if needed, change UB to have the two most nearly
  // equal sides first.
  if (a_c_diff <= a_b_diff && a_c_diff <= b_c_diff) {
    OrientedLattice::GetUB(UB, c, a, b);
  } else if (b_c_diff <= a_b_diff && b_c_diff <= a_c_diff) {
    OrientedLattice::GetUB(UB, b, c, a);
  }
}
 
void ConventionalCell::StandardizeHexagonal(Kernel::DblMatrix &UB) {
  V3D a;
  V3D b;
  V3D c;
  OrientedLattice::GetABC(UB, a, b, c);
 
  double alpha = b.angle(c) * 180.0 / M_PI;
  double beta = c.angle(a) * 180.0 / M_PI;
  // first, make the non 90
  // degree angle last
  if (fabs(alpha - 90) > 20) {
    OrientedLattice::GetUB(UB, b, c, a);
  } else if (fabs(beta - 90) > 20) {
    OrientedLattice::GetUB(UB, c, a, b);
  }
  // if the non 90 degree angle
  // is about 60 degrees, make
  // it about 120 degrees.
  OrientedLattice::GetABC(UB, a, b, c);
  double gamma = a.angle(b) * 180.0 / M_PI;
  if (fabs(gamma - 60) < 10) {
    a = a * (-1);                        // reflect a and c to change
    c = c * (-1);                        // alpha and gamma to their
    OrientedLattice::GetUB(UB, a, b, c); // supplementary angle
  }
}
 
} // namespace Mantid::Geometry