FilterEventsByLogValuePreNexus.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2010 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/DeprecatedAlgorithm.h"
#include "MantidAPI/IFileLoader.h"
#include "MantidDataHandling/DllConfig.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/Events.h"
#include "MantidKernel/BinaryFile.h"
#include "MantidKernel/FileDescriptor.h"
#include <fstream>
#include <string>
#include <vector>
 
namespace Mantid {
namespace DataHandling {
#undef LOADEVENTPRENEXUS_ALLOW_PARALLEL
 
using PixelType = int;
 
using DasTofType = int;
 
#pragma pack(push, 4) // Make sure the structure is 8 bytes.
struct DasEvent {
  DasTofType tof;
  PixelType pid;
};
#pragma pack(pop)
 
#pragma pack(push, 4) // Make sure the structure is 8 bytes.
struct IntermediateEvent {
  DasTofType tof;
  PixelType pid;
  size_t frame_index;
  uint32_t period;
};
#pragma pack(pop)
 
#pragma pack(push, 4) // Make sure the structure is 16 bytes.
struct Pulse {
  uint32_t nanoseconds;
 
  uint32_t seconds;
 
  uint64_t event_index;
 
  double pCurrent;
};
#pragma pack(pop)
 
class MANTID_DATAHANDLING_DLL FilterEventsByLogValuePreNexus : public API::IFileLoader<Kernel::FileDescriptor>,
                                                               public API::DeprecatedAlgorithm {
public:
  FilterEventsByLogValuePreNexus();
  ~FilterEventsByLogValuePreNexus() override;
  const std::string name() const override { return "FilterEventsByLogValuePreNexus"; }
  int version() const override { return (2); }
  const std::string category() const override { return "DataHandling\\PreNexus"; }
  const std::string alias() const override { return "LoadEventPreNeXus2"; }
  const std::string summary() const override {
    return "Load and split SNS raw neutron event data format and stores it in "
           "a workspace";
  }
 
  int confidence(Kernel::FileDescriptor &descriptor) const override;
 
private:
  void init() override;
  void exec() override;
 
  void processProperties();
 
  DataObjects::EventWorkspace_sptr setupOutputEventWorkspace();
 
  void loadPixelMap(const std::string &filename);
 
  void openEventFile(const std::string &filename);
 
  void readPulseidFile(const std::string &filename, const bool throwError);
 
  void runLoadInstrument(const std::string &eventfilename, const API::MatrixWorkspace_sptr &localWorkspace);
 
  void procEvents(DataObjects::EventWorkspace_sptr &workspace);
 
  void procEventsLinear(DataObjects::EventWorkspace_sptr &workspace,
                        std::vector<Types::Event::TofEvent> **arrayOfVectors, DasEvent *event_buffer,
                        size_t current_event_buffer_size, size_t fileOffset);
 
  void setProtonCharge(DataObjects::EventWorkspace_sptr &workspace);
 
  void addToWorkspaceLog(const std::string &logtitle, size_t mindex);
 
  void processEventLogs();
 
  size_t padOutEmptyPixels(const DataObjects::EventWorkspace_sptr &eventws);
 
  void setupPixelSpectrumMap(const DataObjects::EventWorkspace_sptr &eventws);
 
  void filterEvents();
  void filterEventsLinear(DataObjects::EventWorkspace_sptr &workspace,
                          std::vector<Types::Event::TofEvent> **arrayOfVectors, DasEvent *event_buffer,
                          size_t current_event_buffer_size, size_t fileOffset);
 
  void unmaskVetoEventIndexes();
 
  int findRunFrequency();
 
  void debugOutput(bool doit, size_t mindex);
 
  void doStatToEventLog(size_t mindex);
 
  std::unique_ptr<Mantid::API::Progress> m_progress = nullptr;
 
  DataObjects::EventWorkspace_sptr m_localWorkspace; //< Output EventWorkspace
  std::vector<int64_t> m_spectraList;                
 
  std::vector<Types::Core::DateAndTime> pulsetimes;
  std::vector<uint64_t> m_vecEventIndex;
  std::vector<double> m_protonCharge;
  double m_protonChargeTot;
  std::vector<std::size_t> m_pixelToWkspindex;
  std::vector<PixelType> m_pixelmap;
 
  Mantid::detid_t m_detid_max;
 
  std::unique_ptr<Mantid::Kernel::BinaryFile<DasEvent>> m_eventFile;
  std::size_t m_numEvents; 
  std::size_t m_numPulses; 
  uint32_t m_numPixel;     
 
  std::size_t m_numGoodEvents;       
  std::size_t m_numErrorEvents;      
  std::size_t m_numBadEvents;        
  std::size_t m_numWrongdetidEvents; 
  std::set<PixelType> wrongdetids; 
  std::map<PixelType, size_t> wrongdetidmap;
  std::vector<std::vector<Types::Core::DateAndTime>> wrongdetid_pulsetimes;
  std::vector<std::vector<double>> wrongdetid_tofs;
 
  std::size_t m_numIgnoredEvents;
  std::size_t m_firstEvent;   
  std::size_t m_maxNumEvents; 
 
  bool m_usingMappingFile;
 
  bool m_loadOnlySomeSpectra;
  std::map<int64_t, bool> spectraLoadMap;
 
  double m_longestTof;
  double m_shortestTof;
 
  bool m_parallelProcessing;
 
  bool m_pulseTimesIncreasing;
 
  std::vector<detid_t> mSEids;
  std::map<size_t, detid_t> mSEmap;
  std::vector<std::vector<int64_t>> mSEpulseids;
  std::vector<std::vector<double>> mSEtofs;
 
  std::string m_eventFileName;
 
  std::string m_pulseIDFileName;
  bool m_throwError;
 
  std::string m_functionMode;
 
  bool m_examEventLog;
 
  int m_pixelid2exam;
 
  int m_numevents2write;
 
  std::vector<int> m_vecLogPixelID;
  std::vector<std::string> m_vecLogPixelTag;
 
  DataObjects::EventWorkspace_sptr m_localWorkspaceBA;
 
  int m_freqHz;
 
  int64_t m_istep;
 
  int64_t m_dbPixelID;
  bool m_useDBOutput;
 
  bool m_corretctTOF;
};
} // namespace DataHandling
} // namespace Mantid