/data/refman/pasoursint/CMSSW_6_1_1/src/DataFormats/EcalDigi/interface/EcalMatacqDigi.h

Go to the documentation of this file.

// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 8; -*-
//$Id: EcalMatacqDigi.h,v 1.6 2011/08/30 18:42:57 wmtan Exp $

#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();
  };
  
  
  const float adcCount(const int& i) const { return data_[i]; }

  const 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