FindDetectorsPar.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2009 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 <float.h>
#include <fstream>
 
#include "MantidAPI/Algorithm.h"
#include "MantidDataHandling/DllConfig.h"
#include "MantidGeometry/IDetector.h"
 
namespace Mantid {
namespace DataHandling {
enum fileTypes {
  PAR_type, //< ASCII PAR file
  PHX_type, //< ASCII phx file
  SPE_type, //< spe file, this loader would not work with spe file, left for
  // compartibility with old algorithms.
  BIN_file, //< binary file is not an ASCII file, so ascii loader would not work
  // on it
  NumFileTypes
};
 
struct FileTypeDescriptor {
  fileTypes Type;
  std::streampos data_start_position; //< the position in the file where the
  // data structure starts
  size_t nData_records, //< number of data records -- actually nDetectors
      nData_blocks;     //< nEnergy bins for SPE file, 5 or 6 for PAR file and 7 for
  // PHX file
  char line_end; //< the character which ends line in current ASCII file 0x0A
                 //(LF)
  // Unix, 0x0D (CR) Mac and 0x0D 0x0A (CR LF) Win, but the last is interpreted
  // as 0x0A here
  FileTypeDescriptor() : Type(BIN_file), data_start_position(0), nData_records(0), nData_blocks(0), line_end(0x0A) {}
};
 
// predefine class, used to cashe precalculated detector's parameters
class DetParameters;
 
class MANTID_DATAHANDLING_DLL FindDetectorsPar : public API::Algorithm {
public:
  virtual ~FindDetectorsPar() = default;
  const std::string name() const override { return "FindDetectorsPar"; };
  const std::string summary() const override {
    return "The algorithm returns the angular parameters and second flight "
           "path for a workspace detectors (data, usually availble in par or "
           "phx file)";
  }
 
  int version() const override { return 1; };
  const std::string category() const override { return "DataHandling\\Instrument"; }
  std::vector<double> const &getAzimuthal() const { return azimuthal; }
  std::vector<double> const &getPolar() const { return polar; }
  std::vector<double> const &getAzimWidth() const { return azimuthalWidth; }
  std::vector<double> const &getPolarWidth() const { return polarWidth; }
  std::vector<double> const &getFlightPath() const { return secondaryFlightpath; }
  std::vector<size_t> const &getDetID() const { return detID; }
  size_t getNDetectors() const { return m_nDetectors; }
 
private:
  // Implement abstract Algorithm methods
  void init() override;
  void exec() override;
  bool m_SizesAreLinear = false;
 
  // numner of real(valid and non-monitor) detectors calculated by the alvorithm
  size_t m_nDetectors = 0;
  // the vectors which represent detector's parameters as linear structure
  std::vector<double> azimuthal;
  std::vector<double> polar;
  std::vector<double> azimuthalWidth;
  std::vector<double> polarWidth;
  std::vector<double> secondaryFlightpath;
  std::vector<size_t> detID;
 
  // calculate generic detectors parameters:
  void calcDetPar(const Geometry::IDetector &detector, const Kernel::V3D &observer, DetParameters &detParameters);
 
  FileTypeDescriptor current_ASCII_file;
  void setOutputTable();
  void extractAndLinearize(const std::vector<DetParameters> &detPar);
  void populate_values_from_file(const API::MatrixWorkspace_sptr &inputWS);
  size_t loadParFile(const std::string &fileName);
 
protected: // for testing purposes
  int count_changes(const char *const Buf, size_t buf_size);
  size_t get_my_line(std::ifstream &in, char *buf, size_t buf_size, const char DELIM);
  FileTypeDescriptor get_ASCII_header(std::string const &fileName, std::ifstream &data_stream);
  void load_plain(std::ifstream &stream, std::vector<double> &Data, FileTypeDescriptor const &FILE_TYPE);
};
 
class DetParameters {
public:
  double azimutAngle;
  double polarAngle;
  double secondaryFlightPath;
  double azimWidth, polarWidth;
  int64_t detID;
  // default detector ID -- -1 means undefined
  DetParameters()
      : azimutAngle(0.), polarAngle(0.), secondaryFlightPath(0.), azimWidth(0.), polarWidth(0.), detID(-1) {}
};
 
class AvrgDetector {
  double m_AzimutSum;
  double m_PolarSum;
  double m_FlightPathSum;
  double m_AzimBase, m_PolarBase;
  // if azimuthal and polar sizes expressed in angular or linear units
  bool m_useSphericalSizes;
  double m_AzimMin, m_PolarMin, m_AzimMax, m_PolarMax;
  size_t m_nComponents;
 
public:
  AvrgDetector()
      : m_AzimutSum(0), m_PolarSum(0), m_FlightPathSum(0), m_AzimBase(0), m_PolarBase(0), m_useSphericalSizes(false),
        m_AzimMin(FLT_MAX), m_PolarMin(FLT_MAX), m_AzimMax(-FLT_MAX), m_PolarMax(-FLT_MAX), m_nComponents(0) {}
  void addDetInfo(const Geometry::IDetector &det, const Kernel::V3D &Observer);
  void returnAvrgDetPar(DetParameters &avrgDet);
 
  void setUseSpherical(bool shouldWe = true) { m_useSphericalSizes = shouldWe; }
 
  static double nearAngle(const double &baseAngle, const double &anAngle);
};
 
} // end namespace DataHandling
} // namespace Mantid