EcalTBEventHeader.h

Go to the documentation of this file.

#ifndef RECECAL_ECALTBEVENTHEADER_H
#define RECECAL_ECALTBEVENTHEADER_H 1

#include <ostream>
#include <string>
#include <vector>
#include "DataFormats/EcalDetId/interface/EBDetId.h"

class EcalTBEventHeader {

 public:
  
  EcalTBEventHeader() {};
  
  ~EcalTBEventHeader() {};

  typedef struct magnetsMeasurement {
    int    magnet6IRead_ampere;
    int    magnet6ISet_ampere;

    int    magnet7IRead_ampere;
    int    magnet7ISet_ampere;

    int    magnet7VMeas_uvolt;
    int    magnet7IMeas_uampere;

    int    magnet6VMeas_uvolt;
    int    magnet6IMeas_uampere;
  } magnetsMeasurement_t;

  int eventNumber() const{
    return eventNumber_;
  }

  int runNumber() const{
    return runNumber_;
  }

  short burstNumber() const{
    return burstNumber_;
  }

  short smInBeam() const {
    return smInBeam_;
  }

  int begBurstTimeSec() const{
    return begBurstTime_sec_;
  }

  int begBurstTimeMsec() const{
    return begBurstTime_msec_;
  }

  int endBurstTimeSec() const{
    return endBurstTime_sec_;
  }

  int endBurstTimeMsec() const{
    return endBurstTime_msec_;
  }

  int begBurstLV1A() const{
    return begBurstLV1A_;
  }

  int endBurstLV1A() const{
    return endBurstLV1A_;
  }
  

  // Return the event type: "beam", "laser", "pedestal". "error"
  // or a number orresponding to the orginal eventype stored in 
  // the RRF. 
  std::string eventType() const ;

  int dbEventType() const ;

  int triggerMask() const {
    return triggerMask_;
  }

  int date() const {
    return date_;
  }


  //Table supervisor information
  int crystalInBeam() const {
    return EBDetId(crystalInBeam_).ic();
  }
  int nominalCrystalInBeam() const {
    return EBDetId(nominalCrystalInBeam_).ic();
  }
  int nextCrystalInBeam() const {
    return EBDetId(nextCrystalInBeam_).ic();
  }
  unsigned int thetaTableIndex() const { return thetaTableIndex_; }
  unsigned int phiTableIndex() const { return phiTableIndex_; }
  bool tableIsMoving() const { return tableIsMoving_;} 
  bool tableIsMovingAtBegSpill() const { return tableIsMovingAtBegSpill_; }
  bool syncError() const { return syncError_; }


  // FIXME: add the codes used by Jean Bourotte here.
  enum LaserType {
    LBlue     = 440, 
    LGreen    = 495, 
    LRed      = 709, 
    LInfrared = 800  
  };
  int lightIntensity() const {
    return lightIntensity_;
  }
  int laserType() const {
    return laserType_; // returns wavelength
  }

  LaserType laserTypeName() const {
    LaserType laser_type;
    switch(laserType_){
    case 440:  laser_type = LBlue;       break;
    case 495:  laser_type = LGreen;      break;
    case 709:  laser_type = LRed;        break;
    case 800:  laser_type = LInfrared;   break;
    default:   laser_type = LRed;        break;
    }
    return laser_type; // returns laserTypeName
  }

  int S6ADC () const { 
    return S6ADC_ ; 
    }

  int  numberOfMagnetMeasurements() const { return numberOfMagnetMeasurements_; }
  
  const std::vector<magnetsMeasurement_t>&  magnetMeasurements() const { return magnetMeasurements_; }

  int  scaler(int scalerId) const {
    if (scalerId < ((int) scalers_.size() ) )
      return scalers_[scalerId];
    else
      return -1;
  }
  
  //Set Methods

  void setEventNumber(const int& eventNumber) { eventNumber_=eventNumber; }

  void setRunNumber(const int& runNumber) { runNumber_=runNumber; }

  void setSmInBeam(const int& smInBeam) { smInBeam_ = smInBeam; }

  void setBurstNumber(const short& burstNumber ) { burstNumber_=burstNumber; }

  void setTriggerMask(const int& triggerMask ) { triggerMask_=triggerMask; }

  void setBegBurstTimeSec(const int&  begBurstTimeSec) { begBurstTime_sec_ = begBurstTimeSec; }

  void setBegBurstTimeMsec(const int&  begBurstTimeMsec) { begBurstTime_msec_ = begBurstTimeMsec; }

  void setEndBurstTimeSec(const int&  endBurstTimeSec) { endBurstTime_sec_ = endBurstTimeSec; }

  void setEndBurstTimeMsec(const int&  endBurstTimeMsec) { endBurstTime_msec_ = endBurstTimeMsec; }

  void setBegBurstLV1A(const int&  begBurstLV1A) { begBurstLV1A_ = begBurstLV1A; }

  void setEndBurstLV1A(const int&  endBurstLV1A) { endBurstLV1A_ = endBurstLV1A; }

  void setDate(const int& date ) { date_=date; }

  void setCrystalInBeam(const DetId& crystalInBeam ) { crystalInBeam_=crystalInBeam; }

  void setNominalCrystalInBeam(const DetId& crystalInBeam ) { nominalCrystalInBeam_=crystalInBeam; }

  void setNextCrystalInBeam(const DetId& crystalInBeam ) { nextCrystalInBeam_=crystalInBeam; }

  void setThetaTableIndex(const unsigned int& thetaTableIndex ) { thetaTableIndex_=thetaTableIndex; }

  void setPhiTableIndex(const unsigned int& phiTableIndex ) { phiTableIndex_=phiTableIndex; }

  void setTableIsMoving(const bool& tableIsMoving ) { tableIsMoving_=tableIsMoving; }

  void setTableIsMovingAtBegSpill(const bool& tableIsMoving ) { tableIsMovingAtBegSpill_=tableIsMoving; }

  void setSyncError(const bool& syncError ) { syncError_ = syncError; }

  void setLightIntensity(const int& lightIntensity) { lightIntensity_=lightIntensity; }

  void setLaserType(const int& laserType) { laserType_ = laserType; }

  void setS6ADC (const int& S6ADC) { S6ADC_ = S6ADC ; }

  void setNumberOfMagnetMeasurements(const int& numberOfMagnetMeasurements) { numberOfMagnetMeasurements_ = numberOfMagnetMeasurements;}
  void setMagnetMeasurements(const std::vector<magnetsMeasurement_t>& magnetMeasurements) { magnetMeasurements_ = magnetMeasurements;}

  void setScalers (const std::vector<int> & scalers) { scalers_ = scalers; }


 private:

  int      eventNumber_;      
  int      runNumber_;        
  short    burstNumber_;      


  int      begBurstTime_sec_;
  int      begBurstTime_msec_;
  int      endBurstTime_sec_;
  int      endBurstTime_msec_;
  int      begBurstLV1A_;
  int      endBurstLV1A_;


  int      triggerMask_;      

  int      numberOfMagnetMeasurements_;
  std::vector<magnetsMeasurement_t> magnetMeasurements_;
  
  /*   int      nominalMagnet6ReadAmpere_; */
  /*   int      nominalMagnet7ReadAmpere_; */
  /*   int      nominalMagnet6SetAmpere_; */
  /*   int      nominalMagnet7SetAmpere_; */
  /*   int      measuredMagnet6MicroAmpere_; */
  /*   int      measuredMagnet7MicroAmpere_; */
  /*   int      measuredMagnet6Volt_; */
  /*   int      measuredMagnet7Volt_; */


  int      date_;             

  DetId    crystalInBeam_;    
  DetId    nominalCrystalInBeam_;    
  DetId    nextCrystalInBeam_;    
  unsigned int    thetaTableIndex_; 
  unsigned int    phiTableIndex_;   

  bool tableIsMoving_;

  bool tableIsMovingAtBegSpill_; //indipendent but from CAMAC one saying if table is moving at the begin of the spill

  //Sync error for Camac stuff
  bool syncError_;

  //FIXME for use in CMSSW(Probably unuseful when reading from new RawData Information will be stored in EcalDCCHeaderBlock)
  int      lightIntensity_;   
  int      laserType_;        

  int      S6ADC_ ;           

  short smInBeam_;

  // array of 36 scalers
  std::vector<int> scalers_;

};

std::ostream& operator<<(std::ostream&, const EcalTBEventHeader&);
  
#endif