MatacqProducer.h

Go to the documentation of this file.

#ifndef PRODUCER_H
#define PRODUCER_H

//#define USE_STORAGE_MANAGER

#ifdef USE_STORAGE_MANAGER
#include "Utilities/StorageFactory/interface/Storage.h"
#include "Utilities/StorageFactory/interface/StorageFactory.h"
#else  //USE_STORAGE_MANAGER not defined
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
#endif  //_LARGEFILE64_SOURCE not defined
#define _FILE_OFFSET_BITS 64
#include <cstdio>
#endif  //USE_STORAGE_MANAGER defined

#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "EventFilter/EcalRawToDigi/interface/MatacqRawEvent.h"
#include "EventFilter/EcalRawToDigi/src/MatacqDataFormatter.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"

#include <string>
#include <cinttypes>
#include <fstream>
#include <memory>

#include <sys/time.h>

struct NullOut {
  NullOut& operator<<(std::ostream& (*pf)(std::ostream&)) { return *this; }
  template <typename T>
  inline NullOut& operator<<(const T& a) {
    return *this;
  }
};

class MatacqProducer : public edm::EDProducer {
public:
  enum calibTrigType_t { laserType = 4, ledType = 5, tpType = 6, pedType = 7 };

private:
#ifdef USE_STORAGE_MANAGER
  typedef IOOffset filepos_t;
  typedef std::unique_ptr<Storage> FILE_t;
#else
  typedef off_t filepos_t;
  typedef FILE* FILE_t;
#endif
  struct MatacqEventId {
    MatacqEventId() : run(0), orbit(0) {}
    MatacqEventId(uint32_t r, uint32_t o) : run(r), orbit(o) {}

    uint32_t run;

    uint32_t orbit;

    bool operator<(const MatacqEventId& a) {
      return (this->run < a.run) || ((this->run == a.run) && (this->orbit < a.orbit));
    }

    bool operator>(const MatacqEventId& a) {
      return (this->run > a.run) || ((this->run == a.run) && (this->orbit > a.orbit));
    }

    bool operator==(const MatacqEventId& a) { return !((*this) < a || (*this) > a); }
  };

  class PosEstimator {
    //Note: a better estimate could be obtained by using segment of linear
    //functions. In such implementation, the estimator must be updated
    //each time a point with wrong estimate has been found.
  public:
    PosEstimator() : eventLength_(0), orbitStepMean_(0), firstOrbit_(0), invalid_(true), verbosity_(0) {}
    void init(MatacqProducer* mp);
    bool invalid() const { return invalid_; }
    int64_t pos(int orb) const;
    int eventLength() const { return eventLength_; }
    int firstOrbit() const { return firstOrbit_; }
    void verbosity(int verb) { verbosity_ = verb; }

  private:
    int eventLength_;
    int orbitStepMean_;
    int firstOrbit_;
    bool invalid_;
    int verbosity_;
  };

public:
  explicit MatacqProducer(const edm::ParameterSet& params);

  ~MatacqProducer() override;

  void produce(edm::Event& event, const edm::EventSetup& eventSetup) override;

private:
  void addMatacqData(edm::Event& event);

  bool getMatacqFile(uint32_t runNumber, uint32_t orbitId, bool* fileChange = nullptr);

  bool getMatacqEvent(uint32_t runNumber, int32_t orbitId, bool fileChange);
  /*,bool doWrap = false, std::streamoff maxPos = -1);*/

  uint32_t getRunNumber(edm::Event& ev) const;
  uint32_t getOrbitId(edm::Event& ev) const;

  bool getOrbitRange(uint32_t& firstOrb, uint32_t& lastOrb);

  int getCalibTriggerType(edm::Event& ev) const;

  void loadOrbitOffset();

  bool mseek(filepos_t offset, int whence = SEEK_SET, const char* mess = nullptr);

  bool mtell(filepos_t& pos);

  bool mread(char* buf, size_t n, const char* mess = nullptr, bool peek = false);

  bool mcheck(const std::string& name);

  bool mopen(const std::string& name);

  void mclose();

  bool misOpened();

  bool meof();

  bool mrewind();

  bool msize(filepos_t& s);

  void newRun(int prevRun, int newRun);

  static std::string runSubDir(uint32_t runNumber);

private:
  std::vector<std::string> fileNames_;

  std::string digiInstanceName_;

  std::string rawInstanceName_;

  bool timing_;

  bool disabled_;

  int verbosity_;

  bool produceDigis_;

  bool produceRaw_;

  edm::InputTag inputRawCollection_;

  edm::EDGetTokenT<FEDRawDataCollection> inputRawCollectionToken_;

  bool mergeRaw_;

  bool ignoreTriggerType_;

  MatacqRawEvent matacq_;

  FILE_t inFile_;

  static const int bufferSize = 30000;  //must greater or equal to maximum
  //                                      matacq event size.
  std::vector<unsigned char> data_;
  MatacqDataFormatter formatter_;
  const static int orbitTolerance_;
  uint32_t openedFileRunNumber_;
  int32_t lastOrb_;
  int fastRetrievalThresh_;

  PosEstimator posEstim_;

  timeval startTime_;

  std::string orbitOffsetFile_;

  std::map<uint32_t, uint32_t> orbitOffset_;

  bool doOrbitOffset_;

  std::string inFileName_;

  static const int matacqFedId_ = 655;

  struct stats_t {
    double nEvents;
    double nLaserEventsWithMatacq;
    double nNonLaserEventsWithMatacq;
  } stats_;

  const static stats_t stats_init;
  std::string logFileName_;

  std::ofstream logFile_;

  int eventSkipCounter_;

  int onErrorDisablingEvtCnt_;

  std::string timeLogFile_;
  timeval timer_;

  std::ofstream timeLog_;

  bool logTiming_;

  uint32_t runNumber_;
};

#endif