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; }
 
  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;
#endif
  }
 
#endif
 
private:
  int chId_;
 
  std::vector<Short_t> data_;
 
  int freq;
 
  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