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/interface/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_ */