GctFormatTranslateBase.h

Go to the documentation of this file.

#ifndef GctFormatTranslateBase_h_
#define GctFormatTranslateBase_h_
 
// C++ includes
#include <map>
#include <utility>
#include <string>
 
// CMSSW includes
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "L1Trigger/TextToDigi/src/SourceCardRouting.h"
#include "EventFilter/GctRawToDigi/src/GctBlockHeader.h"
#include "EventFilter/GctRawToDigi/src/GctUnpackCollections.h"
 
class GctFormatTranslateBase {
public:
 
  explicit GctFormatTranslateBase(bool hltMode = false, bool unpackSharedRegions = false);
 
  virtual ~GctFormatTranslateBase();  
 
  void setUnpackCollections(GctUnpackCollections* const collections) { m_collections = collections; }
 
  // Set the bunch crossing ID that will be put into the block headers when packing raw data (i.e. Digi -> Raw).
  void setPackingBxId(uint32_t bxId) { m_packingBxId = bxId; }
 
  // Set the event ID that will be put into the block headers when packing raw data (i.e. Digi -> Raw).
  void setPackingEventId(uint32_t eventId) { m_packingEventId = eventId; }
 
  virtual GctBlockHeader generateBlockHeader(const unsigned char* data) const = 0;
 
  const std::string& getBlockDescription(const GctBlockHeader& header) const;
 
  virtual bool convertBlock(const unsigned char* d, const GctBlockHeader& hdr) = 0;
 
protected:
  /* PROTECTED TYPDEFS, ENUMS, AND CLASS CONSTANTS. */
 
 
  enum EmCandCatagory { NON_ISO_EM_CANDS, ISO_EM_CANDS, NUM_EM_CAND_CATEGORIES };
 
 
  enum JetCandCategory { TAU_JETS, FORWARD_JETS, CENTRAL_JETS, NUM_JET_CATEGORIES };
 
  typedef std::map<unsigned int, unsigned int> BlockLengthMap;    
  typedef std::pair<unsigned int, unsigned int> BlockLengthPair;  
  typedef std::map<unsigned int, std::string> BlockNameMap;       
  typedef std::pair<unsigned int, std::string> BlockNamePair;     
 
  typedef std::map<unsigned int, unsigned int> BlkToRctCrateMap;
 
  typedef std::pair<unsigned int, unsigned int> IsoBoundaryPair;
 
  typedef std::map<unsigned int, IsoBoundaryPair> BlockIdToEmCandIsoBoundMap;
 
  /* PROTECTED METHODS */
 
  /* Static data member access methods */
  virtual const BlockLengthMap& blockLengthMap() const = 0;  
 
  virtual const BlockNameMap& blockNameMap() const = 0;  
 
  virtual const BlkToRctCrateMap& rctEmCrateMap()
      const = 0;  
 
  virtual const BlkToRctCrateMap& rctJetCrateMap() const = 0;  
 
  virtual const BlockIdToEmCandIsoBoundMap& internEmIsoBounds()
      const = 0;  
 
  /* Data member access methods */
  GctUnpackCollections* const colls() const {
    return m_collections;
  }                                           
  bool hltMode() const { return m_hltMode; }  
  bool unpackSharedRegions() const {
    return m_unpackSharedRegions;
  }  
  const SourceCardRouting& srcCardRouting() const {
    return m_srcCardRouting;
  }                                                                   
  const uint32_t packingBxId() const { return m_packingBxId; }        
  const uint32_t packingEventId() const { return m_packingEventId; }  
 
  /* Other general methods */
  L1GctJetCandCollection* const gctJets(const unsigned cat) const;
 
  virtual uint32_t generateRawHeader(const uint32_t blockId,
                                     const uint32_t nSamples,
                                     const uint32_t bxId,
                                     const uint32_t eventId) const = 0;
 
 
  void writeRawHeader(unsigned char* data, uint32_t blockId, uint32_t nSamples) const;
 
  bool checkBlock(const GctBlockHeader& hdr) const;
 
  void blockDoNothing(const unsigned char* d, const GctBlockHeader& hdr) {}
 
private:
  /* PRIVATE STATIC CONSTS */
  static const std::string INVALID_BLOCK_HEADER_STR;
 
  /* PRIVATE MEMBER DATA */
 
  GctUnpackCollections* m_collections;
 
  bool m_hltMode;
 
 
  bool m_unpackSharedRegions;
 
  SourceCardRouting m_srcCardRouting;
 
  uint32_t m_packingBxId;
 
  uint32_t m_packingEventId;
};
 
#endif /* GctFormatTranslateBase_h_ */