TileDigitsCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TileDigitsCollection_H
#define TileDigitsCollection_H
 
#include "TileEvent/TileDigits.h"
#include "TileEvent/TileRawDataCollection.h"
 
// STL include
#include <vector>
 
// Lang include
#include <inttypes.h>
 
class TileDigitsCollection : public TileRawDataCollection<TileDigits>
{
  friend class TileDigitsContainerCnv;
public:
 
  typedef TileRawDataCollection<TileDigits> MyBase;
  typedef MyBase::ID ID;
  typedef TileDigits TElement;
 
  TileDigitsCollection ( ID id, SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS  )
    : MyBase(id,ownPolicy), m_FragSize(0), m_FragBCID(0) { m_FragExtraWords.resize(2); }
  // Alternate constructor for use with ConstDataVector.
  TileDigitsCollection ( SG::OwnershipPolicy ownPolicy, ID id  )
    : MyBase(id,ownPolicy), m_FragSize(0), m_FragBCID(0) { m_FragExtraWords.resize(2); }
  TileDigitsCollection ( SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS ) 
    : MyBase(ownPolicy), m_FragSize(0), m_FragBCID(0) { m_FragExtraWords.resize(2); }
 
  TileDigitsCollection ( SG::OwnershipPolicy ownPolicy, ID id,
                         uint32_t lvl1Id, uint32_t lvl1Type, uint32_t detEvType, uint32_t rodBCID,
                         const std::vector<uint32_t>& fragChipCRCWords, const std::vector<uint32_t>& fragChipCRCWordsHIGH,
                         const std::vector<uint32_t>& fragChipHeaderWords, const std::vector<uint32_t>& fragChipHeaderWordsHIGH,
                         const std::vector<uint32_t>& fragExtraWords, uint32_t fragSize, uint32_t fragBCID)
    : MyBase(id, ownPolicy, lvl1Id, lvl1Type, detEvType, rodBCID),
      m_FragChipCRCWords(fragChipCRCWords), m_FragChipCRCWordsHIGH(fragChipCRCWordsHIGH),
      m_FragChipHeaderWords(fragChipHeaderWords), m_FragChipHeaderWordsHIGH(fragChipHeaderWordsHIGH),
      m_FragExtraWords(fragExtraWords), m_FragSize(fragSize), m_FragBCID(fragBCID) {}

  TileDigitsCollection (const TileDigitsCollection& other);

  TileDigitsCollection(TileDigitsCollection&& other) = default;
 
  ~TileDigitsCollection() { }

  void clear ();

  bool isCalibMode() const { return (size() == 96); }
  void setFragSize(uint32_t s) { m_FragSize = s; }
  inline uint32_t getFragSize() const { return m_FragSize; }
  void setFragExtraWords(const std::vector<uint32_t> & extra) {
    m_FragExtraWords = extra;
    if (extra.size() < 2) m_FragExtraWords.resize(2);
  }
  void setFragExtraWords(std::vector<uint32_t> && extra) {
    m_FragExtraWords = std::move(extra);
    if (m_FragExtraWords.size() < 2) m_FragExtraWords.resize(2);
  }

  inline const std::vector<uint32_t>& getFragExtraWords() const { return m_FragExtraWords; }
  inline uint32_t              getFragExtraWord(unsigned int i) const { 
    if (i<m_FragExtraWords.size()) return m_FragExtraWords[i]; else return 0; }

  inline uint32_t getFragDMUMask() const { return m_FragExtraWords[0]; }
  inline uint32_t getFragCRC() const { return m_FragExtraWords[1]; }
  void setFragBCID(uint32_t bcid) { m_FragBCID = bcid; }
  inline uint32_t getFragBCID() const { return (m_FragBCID & 0xFFFF); }
  inline uint32_t getFragStatus() const { return (m_FragBCID >> 16); }

  void setFragChipHeaderWords(const std::vector<uint32_t>& chipHWords) {
        m_FragChipHeaderWords = chipHWords;
  }
  void setFragChipHeaderWords(std::vector<uint32_t>&& chipHWords) {
        m_FragChipHeaderWords = std::move(chipHWords);
  }

  void setFragChipHeaderWordsHigh(const std::vector<uint32_t>& chipHWordsH) {
        m_FragChipHeaderWordsHIGH = chipHWordsH;
  }
  void setFragChipHeaderWordsHigh(std::vector<uint32_t>&& chipHWordsH) {
        m_FragChipHeaderWordsHIGH = std::move(chipHWordsH);
  }
 

  inline const std::vector<uint32_t>& getFragChipHeaderWords() const {
                         return m_FragChipHeaderWords;
  }

  const std::vector<uint32_t>& getFragChipHeaderWordsHigh() const {
                  return m_FragChipHeaderWordsHIGH;
  }

  void setFragChipCRCWords(const std::vector<uint32_t>& chipCRCWords) {
       m_FragChipCRCWords = chipCRCWords;
  }
  void setFragChipCRCWords(std::vector<uint32_t>&& chipCRCWords) {
       m_FragChipCRCWords = std::move(chipCRCWords);
  }
 

  void setFragChipCRCWordsHigh(const std::vector<uint32_t>& chipCRCWordsH) {
       m_FragChipCRCWordsHIGH = chipCRCWordsH;
  }
  void setFragChipCRCWordsHigh(std::vector<uint32_t>&& chipCRCWordsH) {
       m_FragChipCRCWordsHIGH = std::move(chipCRCWordsH);
  }

  inline const std::vector<uint32_t>& getFragChipCRCWords() const {
                         return m_FragChipCRCWords;
  }

  inline const std::vector<uint32_t>& getFragChipCRCWordsHigh() const {
                         return m_FragChipCRCWordsHIGH;
  }
  
  void printExtra() const;
  void printExtra(std::ostream& os) const;
 
 
private:
  std::vector<uint32_t> m_FragChipCRCWords;
  std::vector<uint32_t> m_FragChipCRCWordsHIGH;
  std::vector<uint32_t> m_FragChipHeaderWords;
  std::vector<uint32_t> m_FragChipHeaderWordsHIGH;

  std::vector<uint32_t> m_FragExtraWords;
  uint32_t m_FragSize;
  uint32_t m_FragBCID;
};
 
CLASS_DEF(TileDigitsCollection,2926,0)
 
#endif