LoadEventPreNexus2.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 LoadEventPreNexus2 : public API::IFileLoader<Kernel::FileDescriptor>,
                                                   public API::DeprecatedAlgorithm {
public:
  LoadEventPreNexus2();
  const std::string name() const override { return "LoadEventPreNexus"; }
  int version() const override { return (2); }
  const std::vector<std::string> seeAlso() const override { return {"LoadPreNexus"}; }
  const std::string category() const override { return "DataHandling\\PreNexus"; }
  const std::string alias() const override { return "LoadEventPreNeXus2"; }
  const std::string summary() const override {
    return "Loads 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;
 
  std::unique_ptr<Mantid::API::Progress> prog = nullptr;
 
  DataObjects::EventWorkspace_sptr localWorkspace; //< Output EventWorkspace
  std::vector<int64_t> spectra_list;               
 
  std::vector<Types::Core::DateAndTime> pulsetimes;
  std::vector<uint64_t> event_indices;
  std::vector<double> proton_charge;
  double proton_charge_tot;
  std::vector<std::size_t> pixel_to_wkspindex;
  std::vector<PixelType> pixelmap;
 
  Mantid::detid_t detid_max;
 
  std::unique_ptr<Mantid::Kernel::BinaryFile<DasEvent>> eventfile;
  std::size_t num_events; 
  std::size_t num_pulses; 
  uint32_t numpixel;      
 
  std::size_t num_good_events;       
  std::size_t num_error_events;      
  std::size_t num_bad_events;        
  std::size_t num_wrongdetid_events; 
  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 num_ignored_events;
  std::size_t first_event; 
  std::size_t max_events;  
 
  bool using_mapping_file;
 
  bool loadOnlySomeSpectra;
  std::map<int64_t, bool> spectraLoadMap;
 
  double longest_tof;
  double shortest_tof;
 
  bool parallelProcessing;
 
  bool 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;
 
  bool m_dbOutput;
  int m_dbOpBlockNumber;
  size_t m_dbOpNumEvents;
  size_t m_dbOpNumPulses;
 
  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);
 
  inline void fixPixelId(PixelType &pixel, uint32_t &period) const;
 
  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, bool dbprint);
 
  void setProtonCharge(DataObjects::EventWorkspace_sptr &workspace);
 
  void addToWorkspaceLog(const std::string &logtitle, size_t mindex);
 
  void processImbedLogs();
 
  void debugOutput(bool doit, size_t mindex);
 
  void unmaskVetoEventIndex();
 
  API::MatrixWorkspace_sptr generateEventDistribtionWorkspace();
 
  void createOutputWorkspace(const std::string &event_filename);
 
  void processInvestigationInputs();
};
} // namespace DataHandling
} // namespace Mantid