EcalMatacqDigi.h

Go to the documentation of this file.

// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 8; -*-

#ifndef ECALMATACQDIGI_H
#define ECALMATACQDIGI_H 1

#include <ostream>
#include <vector>
#include <algorithm>
#include "Rtypes.h"

#define ECAL_MATACQ_DIGI_VERS 2

class EcalMatacqDigi {
public:
  static const double lsb_;

  static const int MAXSAMPLES = 2560;

public:
  typedef int key_type;  //matacq channel id used as key for edm::SortedCollection

public:
  EcalMatacqDigi() : chId_(-1), ts_(0.), tTrigS_(999.), version_(-1) { init(); }

  EcalMatacqDigi(const std::vector<Short_t>& samples,
                 const int& chId,
                 const double& ts,
                 const short& version = -1,
                 const double& tTrig = 999.)
      : chId_(chId), data_(samples), ts_(ts), tTrigS_(tTrig), version_(version) {
    init();
  };

  float adcCount(const int& i) const { return data_[i]; }

  float amplitudeV(const int& i) const { return data_[i] * lsb_; }

  int chId() const { return chId_; }

  int id() const { return chId_; }

  //   /** Sets Matacq electronics channel id
  //    */
  //   void chId(int newChId){ chId_ = newChId;}

  int size() const { return data_.size(); }

  void swap(std::vector<short>& samples) { std::swap(data_, samples); }

  void swap(EcalMatacqDigi& a);

  //   /** Gets time of sample i. i between 0 and size()-1.
  //    */
  //   float t(int i) const { return ts()*i;}

  float ts() const { return ts_; }

  //   /** Sets sampling time period
  //    * @param ts sampling time period in seconds
  //    */
  //   void ts(double newTs){
  //     ts_ = newTs;
  //   }

  float tTrig() const { return tTrigS_; }

  //   /** Sets trigger time position
  //    * @param tTrigS (t_trig-t_0) in seconds, with t_trig the time of MATACQ
  //    * trigger and t_0 the time of the first sample of each MATACQ channel.
  //    */
  //   void tTrig(double tTrigS){
  //     tTrigS_ = tTrigS;
  //   }

  short version() const { return version_; }

  //   /** Sets the raw data format, the digi is issued from.
  //    * @param version internal matacq raw data format version
  //    */
  //   void version(short version){
  //     version_ = version;
  //   }

#if (ECAL_MATACQ_DIGI_VERS >= 2)

  int bxId() const { return bxId_; }

  void bxId(int value) { bxId_ = value; }

  int l1a() const { return l1a_; }

  void l1a(int value) { l1a_ = value; }

  int triggerType() const { return triggerType_; }

  void triggerType(int value) { triggerType_ = value; }

  timeval timeStamp() const {
    timeval value;
    value.tv_sec = tv_sec_;
    value.tv_usec = tv_usec_;
    return value;
  }

  void timeStamp(timeval value) {
    tv_sec_ = value.tv_sec;
    tv_usec_ = value.tv_usec;
  }

  UInt_t orbitId() const { return orbitId_; }

  void orbitId(UInt_t value) { orbitId_ = value; }

  int trigRec() const { return trigRec_; }

  void trigRec(int value) { trigRec_ = value; }

  int postTrig() const { return postTrig_; }

  void postTrig(int value) { postTrig_ = value; }

  std::vector<int> vernier() const { return vernier_; }

  void vernier(const std::vector<int>& value) { vernier_ = value; }

  int delayA() const { return delayA_; }

  void delayA(int value) { delayA_ = value; }

  int emtcDelay() const { return emtcDelay_; }

  void emtcDelay(int value) { emtcDelay_ = value; }

  int emtcPhase() const { return emtcPhase_; }

  void emtcPhase(int value) { emtcPhase_ = value; }

  int attenuation_dB() const { return attenuation_dB_; }

  void attenuation_dB(int value) { attenuation_dB_ = value; }

  int laserPower() const { return laserPower_; }

  void laserPower(int value) { laserPower_ = value; }
#endif

  void init() {
#if (ECAL_MATACQ_DIGI_VERS >= 2)
    bxId_ = -1;
    l1a_ = -1;
    triggerType_ = -1;
    orbitId_ = -1;
    trigRec_ = -1;
    postTrig_ = -1;
    vernier_ = std::vector<Int_t>(4, -1);
    delayA_ = -1;
    emtcDelay_ = -1;
    emtcPhase_ = -1;
    attenuation_dB_ = -1;
    laserPower_ = -1;
    tv_sec_ = 0;
    tv_usec_ = 0;
#endif
  }

private:
  int chId_;

  std::vector<Short_t> data_;

  double ts_;

  double tTrigS_;

  short version_;

#if (ECAL_MATACQ_DIGI_VERS >= 2)

  char triggerType_;

  char attenuation_dB_;

  Short_t bxId_;

  Int_t l1a_;

  /* LHC orbit ID
   */
  Int_t orbitId_;

  Short_t trigRec_;

  Short_t postTrig_;

  std::vector<Int_t> vernier_;

  Int_t delayA_;

  Int_t emtcDelay_;

  Int_t emtcPhase_;

  Int_t laserPower_;

  Long64_t tv_sec_;
  Long64_t tv_usec_;

#endif
};

std::ostream& operator<<(std::ostream& s, const EcalMatacqDigi& digi);

#endif