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