LaserSorter.h

Go to the documentation of this file.

/*
 * $Id: LaserSorter.h,v 1.5 2010/04/20 21:46:27 pgras Exp $
 */

#ifndef EVENT_SELECT_H
#define EVENT_SELECT_H

#include <vector>
#include <iostream>
#include <fstream>
#include <inttypes.h>
#include "boost/ptr_container/ptr_list.hpp"

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"

#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/Provenance/interface/LuminosityBlockID.h"
#include "DataFormats/Provenance/interface/RunID.h"

#include <sys/time.h>
#include <time.h>
#include <map>

class LaserSorter : public edm::EDAnalyzer {
  //inner classes
private:
  struct IndexRecord{
    uint32_t orbit;
    uint32_t filePos;
    bool operator<(const IndexRecord& i) const { return orbit < i.orbit; }
  };
  
  class OutStreamRecord{
  public:
    //default ctor
    OutStreamRecord(int fedId__,
            edm::LuminosityBlockNumber_t startingLumiBlock__,
            std::ofstream* out__,
            std::string& tmpFileName__,
            std::string& finalFileName__):
      fedId_(fedId__),
      startingLumiBlock_(startingLumiBlock__),
      out_(out__),
      tmpFileName_(tmpFileName__), finalFileName_(finalFileName__),
      indexError_(false){
      indices_.reserve(indexReserve_);
    }
    
    int fedId() const { return fedId_; }
    edm::LuminosityBlockNumber_t startingLumiBlock() const{
      return startingLumiBlock_; 
    } 
    std::ofstream* out() const { return out_.get(); }
    std::string finalFileName() const { return finalFileName_; }
    std::string tmpFileName() const { return tmpFileName_; }
    std::vector<IndexRecord> * indices() { return &indices_; }
 
    
    std::set<uint32_t>&  excludedOrbit() { return excludedOrbit_; }   

  private:
    int fedId_;
    edm::LuminosityBlockNumber_t startingLumiBlock_;
    std::auto_ptr<std::ofstream> out_;
    std::string tmpFileName_;
    std::string finalFileName_;
    static std::string emptyString_;

    std::vector<IndexRecord> indices_;

    std::set<uint32_t> excludedOrbit_; 
    
    bool indexError_;

    static size_t indexReserve_;

  };

  //typedefs:
private:
  typedef boost::ptr_list<OutStreamRecord> OutStreamList;
  
  //ctors/dtors
public:
  LaserSorter(const edm::ParameterSet&);
  ~LaserSorter();


  //methods
public:
  virtual void analyze(const edm::Event&, const edm::EventSetup&);
  virtual void endJob();
  virtual void beginJob();

private:
  int dcc2Lme(int dccNum, int dccSide);

  int getDetailedTriggerType(const edm::Handle<FEDRawDataCollection>& rawdata,
                             double* proba = 0);

  void closeOldStreams(edm::LuminosityBlockNumber_t lumiBlock);

  void closeAllStreams();

  
  OutStreamRecord* getStream(int fedId,
                 edm::LuminosityBlockNumber_t lumiBlock);

  bool writeEvent(OutStreamRecord& out, const edm::Event& event,
          int detailedTriggerType,
          const FEDRawDataCollection& data);
  
  bool writeFedBlock(std::ofstream& out,
                     const FEDRawData& data);

  OutStreamList::iterator closeOutStream(OutStreamList::iterator streamRecord);

  OutStreamList::iterator createOutStream(int fedId, 
                      edm::LuminosityBlockNumber_t lumiBlock);

  void writeFileHeader(std::ofstream& out);

  bool writeEventHeader(std::ofstream& out,
                        const edm::Event& evt,
                        int fedId,
                        unsigned nFeds);

  
  void streamFileName(int fedId, edm::LuminosityBlockNumber_t lumiBlock, 
                      std::string& tmpName, std::string& finalName);


  bool isDccEventEmpty(const FEDRawData& data, size_t* dccLen = 0,
               int* nTowerBlocks = 0) const;
  
  void getOutputFedList(const edm::Event& event,
                        const FEDRawDataCollection& data,
                        std::vector<unsigned>& fedIds) const;

  bool readIndexTable(std::ifstream& in, std::string& inName,
                      OutStreamRecord& outRcd, std::string* err);

  bool writeIndexTable(std::ofstream& out,
               std::vector<IndexRecord>& indices);

  bool renameAsBackup(const std::string& fileName,
                      std::string& newFileName);
  

  int readFormatVersion(std::ifstream& in,
                        const std::string& fileName);

  static std::string toString(uint64_t t);

  void restoreStreamsOfLumiBlock(int lumiBlock);

  std::vector<int> getFullyReadoutDccs(const FEDRawDataCollection& data) const;
  
  //fields
private:
  static const int ecalDccFedIdMin_;

  static const int ecalDccFedIdMax_;

  int detailedTrigType_;

  std::ofstream logFile_;

  edm::LuminosityBlockNumber_t lumiBlock_;

  OutStreamList outStreamList_;

  unsigned char formatVersion_;

  std::string outputDir_;

  std::vector<std::string> fedSubDirs_;

  std::string timeLogFile_;

  bool disableOutput_;

  edm::RunNumber_t runNumber_;

  timeval timer_;

  std::ofstream timeLog_;

  bool timing_;

  std::string outputListFile_;

  bool doOutputList_;

  int verbosity_;
  
  std::ofstream outputList_;

#if 0

  bool storeFirstOrbitId_;

  std::ofstream firstOrbitOut_;

  std::string firstOrbitOutputFile_;

  uint32_t minOrbitId_;

#endif

  int iNoFullReadoutDccError_;


  int maxFullReadoutDccError_;  


  int iNoEcalDataMess_;

  int maxNoEcalDataMess_;

  int lumiBlockSpan_;
  
  static const int matacqFedId_ = 655;

  static const int indexOffset32_;

  static const unsigned maxEvents_ = 1<<20;

  struct stats_t {
    double nRead;
    double nWritten;
    double nInvalidDccStrict;
    double nInvalidDccWeak;
    double nRestoredDcc;
  } stats_;
  static stats_t stats_init;
};
  
#endif //EVENT_SELECT_H not defined