GroupDetectors2.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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 "MantidDataHandling/DllConfig.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/GroupingWorkspace.h"
#include "MantidKernel/StringTokenizer.h"
 
#include <map>
 
namespace Mantid {
namespace DataHandling {
class MANTID_DATAHANDLING_DLL GroupDetectors2 final : public API::Algorithm {
public:
  const std::string name() const override { return "GroupDetectors"; };
  const std::string summary() const override {
    return "Sums spectra bin-by-bin, equivalent to grouping the data from a "
           "set of detectors.  Individual groups can be specified by passing "
           "the algorithm a list of spectrum numbers, detector IDs or "
           "workspace indices. Many spectra groups can be created in one "
           "execution via an input file.";
  }
 
  int version() const override { return 2; };
  const std::vector<std::string> seeAlso() const override { return {"SpatialGrouping"}; }
  const std::string category() const override { return "Transforms\\Grouping"; }
 
  std::map<std::string, std::string> validateInputs() override;
 
private:
  class RangeHelper {
  public:
    static void getList(const std::string &line, std::vector<size_t> &outList);
 
  private:
    RangeHelper() = default;
    enum {
      IGNORE_SPACES =
          Mantid::Kernel::StringTokenizer::TOK_TRIM | Mantid::Kernel::StringTokenizer::TOK_IGNORE_EMPTY 
    };
  };
 
  using storage_map = std::map<specnum_t, std::vector<size_t>>;
 
  double m_FracCompl = 0.0;
  storage_map m_GroupWsInds;
 
  // Implement abstract Algorithm methods
  void init() override;
  void exec() override;
  void execEvent();
 
  void getGroups(const API::MatrixWorkspace_const_sptr &workspace, std::vector<int64_t> &unUsedSpec);
  void processFile(const std::string &fname, const API::MatrixWorkspace_const_sptr &workspace,
                   std::vector<int64_t> &unUsedSpec);
  void processXMLFile(const std::string &fname, const API::MatrixWorkspace_const_sptr &workspace,
                      std::vector<int64_t> &unUsedSpec);
  void processGroupingWorkspace(const DataObjects::GroupingWorkspace_const_sptr &groupWS,
                                const API::MatrixWorkspace_const_sptr &workspace, std::vector<int64_t> &unUsedSpec);
  void processMatrixWorkspace(const API::MatrixWorkspace_const_sptr &groupWS,
                              const API::MatrixWorkspace_const_sptr &workspace, std::vector<int64_t> &unUsedSpec);
  int readInt(const std::string &line);
 
  void readFile(const spec2index_map &specs2index, std::istream &File, size_t &lineNum,
                std::vector<int64_t> &unUsedSpec, const bool ignoreGroupNumber);
 
  void readSpectraIndexes(const std::string &line, const spec2index_map &specs2index, std::vector<size_t> &output,
                          std::vector<int64_t> &unUsedSpec, const std::string &seperator = "#");
 
  double fileReadProg(DataHandling::GroupDetectors2::storage_map::size_type numGroupsRead,
                      DataHandling::GroupDetectors2::storage_map::size_type numInHists);
 
  size_t formGroups(const API::MatrixWorkspace_const_sptr &inputWS, const API::MatrixWorkspace_sptr &outputWS,
                    const double prog4Copy, const bool keepAll, const std::set<int64_t> &unGroupedSet,
                    Indexing::IndexInfo &indexInfo);
  size_t formGroupsEvent(const DataObjects::EventWorkspace_const_sptr &inputWS,
                         const DataObjects::EventWorkspace_sptr &outputWS, const double prog4Copy);
 
  template <class TIn, class TOut>
  void moveOthers(const std::set<int64_t> &unGroupedSet, const TIn &inputWS, TOut &outputWS, size_t outIndex);
 
  enum {
    USED = 1000 - INT_MAX, 
    EMPTY_LINE = 1001 - INT_MAX, 
    IGNORE_SPACES = Mantid::Kernel::StringTokenizer::TOK_TRIM 
  };
 
  static const double CHECKBINS; 
  static const double OPENINGFILE; 
  static const double READFILE;    
  static const int INTERVAL = 128; 
};
 
template <class TIn, class TOut>
void GroupDetectors2::moveOthers(const std::set<int64_t> &unGroupedSet, const TIn &inputWS, TOut &outputWS,
                                 size_t outIndex) {
  g_log.debug() << "Starting to copy the ungrouped spectra\n";
  double prog4Copy = (1. - 1. * static_cast<double>(m_FracCompl)) / static_cast<double>(unGroupedSet.size());
 
  // go thorugh all the spectra in the input workspace
  for (auto copyFrIt : unGroupedSet) {
    if (copyFrIt == USED)
      continue; // Marked as not to be used
    size_t sourceIndex = static_cast<size_t>(copyFrIt);
 
    outputWS.getSpectrum(outIndex) = inputWS.getSpectrum(sourceIndex);
 
    // go to the next free index in the output workspace
    outIndex++;
    // make regular progress reports and check for cancelling the algorithm
    if (outIndex % INTERVAL == 0) {
      m_FracCompl += INTERVAL * prog4Copy;
      if (m_FracCompl > 1.0) {
        m_FracCompl = 1.0;
      }
      progress(m_FracCompl);
      interruption_point();
    }
  }
 
  g_log.debug() << name() << " copied " << unGroupedSet.size() - 1 << " ungrouped spectra\n";
}
 
} // namespace DataHandling
} // namespace Mantid