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