CscRawDataCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONBYTESTREAM_CSCCRAWDATACOLLECTION_H
#define MUONBYTESTREAM_CSCCRAWDATACOLLECTION_H
 
 
 
#include "MuonRDO/CscRawData.h"
#include "AthContainers/DataVector.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "Identifier/IdentifierHash.h"
#include <map>

class CscRawDataCollection : public DataVector<CscRawData>
{
 
private:

  uint32_t m_id;
  
  IdentifierHash m_idHash;

  uint16_t m_rodId;
  uint16_t m_subDetectorId;

  uint16_t m_numRPU;  

  bool m_samplingPhase;
 
  bool m_triggerType;

  uint8_t m_firstBitSummary;

  uint32_t m_eventType;

  std::vector<uint16_t> m_rpuID;
  std::vector<uint8_t> m_dataType;

  std::vector<uint16_t> m_spuCount;

  uint32_t m_scaAddress;
 
public:

  typedef uint16_t ID; 
  typedef CscRawData DIGIT; 

  CscRawDataCollection (uint32_t id)
    : DataVector<CscRawData>(), m_id(id) {
    m_numRPU          = 0;
    m_samplingPhase   = false;
    m_triggerType     = false;
    m_firstBitSummary = 0x0;
    m_eventType       = 0x0;
    m_rpuID.clear();
    m_dataType.clear();
    m_spuCount.resize(10,0);
    m_scaAddress     = 0x0;
    m_idHash         = m_id;
    m_rodId           = 0;
    m_subDetectorId   = 0;
  }
 
  CscRawDataCollection ()
    : DataVector<CscRawData>(), m_id(0) {
    m_numRPU          = 0;
    m_samplingPhase   = false;
    m_triggerType     = false;
    m_firstBitSummary = 0x0;
    m_eventType       = 0x0;
    m_rpuID.clear();
    m_dataType.clear();
    m_spuCount.resize(10,0);
    m_scaAddress      = 0x0;
    m_rodId           = 0;
    m_subDetectorId   = 0;
  }
 
  virtual ~CscRawDataCollection() {}

  uint16_t identify() const {return m_id;} 
  
  IdentifierHash identifyHash() const {return m_idHash;}
  
  uint16_t rodId()     const {return m_rodId;}
  uint16_t subDetectorId() const {return m_subDetectorId;}
  uint16_t numRPU()  const { return m_rpuID.size(); }
  const std::vector<uint16_t> & rpuID() const { return m_rpuID; }
  const std::vector<uint8_t> & dataType() const { return m_dataType; }
  bool samplingPhase() const {return  m_samplingPhase; }
  bool triggerType() const { return m_triggerType; }
  uint8_t firstBitSummary() const { return m_firstBitSummary; }
  uint32_t eventType () const { return m_eventType; }
  uint8_t calAmplitude() const;
  uint8_t calLayer() const;
  uint32_t scaAddress() const { return m_scaAddress; }
 
  uint16_t numSamples() const;
  uint16_t latency() const;
  uint8_t  rate() const;

  bool sparsified () const;
  bool neutron () const;
  bool calEnabled() const;

  uint16_t spuCount(unsigned int i) const 
   { 
     if (i<10) return m_spuCount[i];
     else return 0x0;
   }
 
  const std::vector<uint16_t>& spuCount() const  { return m_spuCount; }

  void setRodId (uint16_t rodId) {m_rodId = rodId;}
  void setSubDetectorId (uint16_t subDetectorId) {m_subDetectorId = subDetectorId;}
  void setOnlineId (uint16_t id) {m_id = id; m_idHash = m_id; }
  
  void setIdentifyHash(const IdentifierHash& idHash) { m_idHash=idHash;}
  void set_samplingPhase() { m_samplingPhase = true; }
  void set_samplingPhase(bool flag) { m_samplingPhase = flag; }
  void set_triggerType() { m_triggerType = true; }
  void set_triggerType(bool flag) { m_triggerType = flag; }
  void set_firstBitSummary(const uint8_t summary) { m_firstBitSummary=summary; }
  void set_eventType (const uint32_t eventType ) { m_eventType = eventType; }
 
  void set_scaAddress( const uint32_t sca ) { m_scaAddress = sca; }
  void set_spuCount ( unsigned int i, uint16_t count) 
   { if ( i<10 ) m_spuCount[i]=count; }
  void set_spuCount ( const std::vector<uint16_t>& spuCount)
  { m_spuCount = spuCount; }
 
  void setSamplingRate (const uint16_t rate);
  void setNumSamples (const uint16_t n);
  void setLatency (const uint16_t latency);
  void setNumDPU  (const uint16_t numDPU);
 
  void set_sparsified ();

  void set_neutron ();
  
  void set_enableCal ();

  void set_calAmplitude ( const uint8_t calAmp );

  void set_calLayer     ( const uint8_t calLay );
 
  void setRPUID (const std::vector<uint16_t>& rpuID) { m_rpuID = rpuID; }
  void addRPU (const uint16_t rpuID ) { m_rpuID.push_back(rpuID); }
  void addDataType (const uint8_t dataType ) { m_dataType.push_back(dataType); }
  void set_dataType( const unsigned int i, const uint8_t dataType) {
    if ( i < m_dataType.size() ) m_dataType[i] = dataType;
  }
  void set_dataType( const std::vector<uint8_t>& dataType)
  { m_dataType = dataType; }
};
 
CLASS_DEF(CscRawDataCollection,4184,0)
 
/* Class_Def needed only for persistency */
typedef DataVector<CscRawDataCollection> CSC_RAWDATACOLLECTION_vector;
CLASS_DEF( CSC_RAWDATACOLLECTION_vector, 4179, 1 )
 
std::ostream& operator << ( std::ostream& sl, const CscRawDataCollection& coll);
 
#endif