CorelliCalibrationDatabase.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 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 +
#pragma once
 
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAlgorithms/DllConfig.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/TableWorkspace.h"
 
namespace Mantid {
namespace Algorithms {
 
namespace CorelliCalibration {
static const std::vector<std::string> calibrationTableColumnNames{
    "ComponentName",    "Xposition",        "Yposition",        "Zposition",
    "XdirectionCosine", "YdirectionCosine", "ZdirectionCosine", "RotationAngle"};
static const std::vector<std::string> calibrationTableColumnTypes{"str",    "double", "double", "double",
                                                                  "double", "double", "double", "double"};
 
struct ComponentPosition {
  double x;
  double y;
  double z;
  double xCosine;
  double yCosine;
  double zCosine;
  double rotAngle;
 
  bool equalTo(const ComponentPosition &otherpos, double abstol) {
    if (fabs(x - otherpos.x) >= abstol || fabs(y - otherpos.y) >= abstol || fabs(z - otherpos.z) >= abstol ||
        fabs(xCosine - otherpos.xCosine) >= abstol || fabs(yCosine - otherpos.yCosine) >= abstol ||
        fabs(zCosine - otherpos.zCosine) >= abstol || fabs(rotAngle - otherpos.rotAngle) >= abstol) {
      return false;
    }
    return true;
  }
};
 
class MANTID_ALGORITHMS_DLL CalibrationTableHandler {
public:
  static DataObjects::TableWorkspace_sptr loadComponentCalibrationTable(const std::string &filename,
                                                                        const std::string &tablewsname);
 
  static bool isValidCalibrationTableWorkspace(const DataObjects::TableWorkspace_sptr &calibws, std::string &errormsg);
 
  static DataObjects::TableWorkspace_sptr createCalibrationTableWorkspace(const std::string &wsname, bool iscomponent);
 
  ComponentPosition getComponentCalibratedPosition(const std::string &component);
 
  static void appendCalibration(const DataObjects::TableWorkspace_sptr &tablews, const std::string &datestamp,
                                const ComponentPosition &pos);
 
  static ComponentPosition getLatestCalibratedPosition(const DataObjects::TableWorkspace_sptr &componentcaltable);
 
  static ComponentPosition getCalibratedPosition(const DataObjects::TableWorkspace_sptr &componentcaltable,
                                                 size_t rownumber);
 
  CalibrationTableHandler();
 
  void setCalibrationTable(const DataObjects::TableWorkspace_sptr &calibws);
 
  std::vector<std::string> getComponentNames();
  DataObjects::TableWorkspace_sptr getCalibrationWorkspace() { return mCalibWS; }
 
  DataObjects::TableWorkspace_sptr saveCompomentDatabase(const std::string &datestamp, const std::string &component,
                                                         const std::string &filename);
  void saveCalibrationTable(const std::string &filename);
 
private:
  DataObjects::TableWorkspace_sptr mCalibWS;
  bool isSingleComponentTable;
};
 
} // namespace CorelliCalibration
 
class MANTID_ALGORITHMS_DLL CorelliCalibrationDatabase final : public API::Algorithm {
public:
  const std::string name() const override { return "CorelliCalibrationDatabase"; };
  int version() const override { return 1; };
  const std::string category() const override { return "Diffraction\\Calibration"; };
 
  const std::vector<std::string> seeAlso() const override {
    return {"CorelliPowderCalibrationCreate", "CorelliCalibrationApply"};
  };
 
  const std::string summary() const override {
    return "Save calibrated components' positions and orientations to "
           "database.";
  };
 
  static inline std::string corelliComponentDatabaseName(const std::string &componentname,
                                                         const std::string &directory);
  static inline std::string corelliCalibrationDatabaseName(const std::string &datestamp, const std::string &directory);
 
  static std::string convertTimeStamp(const std::string &run_start_time);
 
  static inline bool isFileExist(const std::string &filepath);
 
  static inline std::string joinPath(const std::string &directory, const std::string &basename);
 
  static std::vector<std::string> retrieveInstrumentComponents(const API::MatrixWorkspace_sptr &ws);
 
private:
  std::map<std::string, std::string> validateInputs() override;
  void init() override;
  void exec() override;
 
  void updateComponentDatabaseFiles(const std::string &calibdbdir,
                                    std::map<std::string, DataObjects::TableWorkspace_sptr> &calibwsmap);
  void loadNonCalibratedComponentDatabase(const std::string &calibddir,
                                          std::map<std::string, DataObjects::TableWorkspace_sptr> &calibwsmap);
  void createOutputCalibrationTable(std::map<std::string, DataObjects::TableWorkspace_sptr> &calibwsmap,
                                    const std::vector<std::string> &orderedcomponents);
  // Create the summary CSV file
  void saveCalibrationTable(const std::string &calibdbdir);
  void setComponentMap(const std::vector<std::string> &componentnames,
                       std::map<std::string, DataObjects::TableWorkspace_sptr> &compmap);
 
  API::MatrixWorkspace_sptr mInputWS;
  DataObjects::TableWorkspace_sptr mInputCalibrationTableWS;
  DataObjects::TableWorkspace_sptr mOutputWS;
  std::string mDateStamp;
};
 
} // namespace Algorithms
} // namespace Mantid