Calibration/CalibData/include/CalibData/EsTime/EsTimeCalibData.h

Go to the documentation of this file.

#ifndef CalibData_EsTimeCalibData_h
#define CalibData_EsTimeCalibData_h
 
/* @class CalibData_EsTimeCalibData_h
 
  calibration data class
  calibration infrastructure
 
*/
 
#include "CalibData/CalibBase1.h"
#include "CalibData/CalibModel.h"
#include <vector>
 
using namespace std;
 
namespace CalibData {
  class EsTimeCalibData : public CalibBase1 {
 
  public:
    EsTimeCalibData();
    virtual ~EsTimeCalibData() {
      if ( m_TestCalibConst ) { delete m_TestCalibConst; }
      if ( m_toffsetb.size() > 0 ) { m_toffsetb.clear(); }
      if ( m_toffsete.size() > 0 ) { m_toffsete.clear(); }
      if ( m_bunchtime.size() > 0 ) { m_bunchtime.clear(); }
      if ( m_runFrom.size() > 0 ) { m_runFrom.clear(); }
      if ( m_runTo.size() > 0 ) { m_runTo.clear(); }
      if ( m_eventFrom.size() > 0 ) { m_eventFrom.clear(); }
      if ( m_eventTo.size() > 0 ) { m_eventTo.clear(); }
      return;
    }
 
    // Re-implemented from DataObject
    inline virtual const CLID& clID() const { return classID(); }
 
    inline static const CLID& classID() { return CLID_Calib_EsTimeCal; }
 
    virtual StatusCode update( CalibBase1& other, MsgStream* log );
 
    // set the Calibdata of EsTime
    void setTestCalibConst( const vector<double>* TestCalibConst );
    void setToffsetb( const double toffsetb );
    void setToffsete( const double toffsete );
    void setBunchTime( const int bunchtime );
    void setRunFrom( const int runFrom );
    void setRunTo( const int runTo );
    void setEventFrom( const int eventFrom );
    void setEventTo( const int eventTo );
 
    // get the CalibData of EsTime
    double getTestCalibConst( unsigned int No ) const {
      return *( ( m_TestCalibConst->begin() ) + No );
    }
    // get the size of the vectors
    int getTestCalibConstNo() const { return m_TestCalibConst->size(); }
    // get the time of offset for barrel
    double getToffsetb();
    double getToffsetb( unsigned int No );
    // get the time of offset for endcap
    double getToffsete();
    double getToffsete( unsigned int No );
    // get the time interval of each bunch
    double getBunchTime();
    double getBunchTime( unsigned int No );
    // get the run begin
    unsigned int getSize() const { return m_bunchtime.size(); }
    int          getRunFrom();
    int          getRunFrom( unsigned int No );
    // get the run end
    int getRunTo();
    int getRunTo( unsigned int No );
    // get the event number begin
    int getEventFrom();
    int getEventFrom( unsigned int No );
    // get the event number end
    int getEventTo();
    int getEventTo( unsigned int No );
 
  private:
    vector<double>* m_TestCalibConst;
    vector<double>  m_toffsetb;
    vector<double>  m_toffsete;
    vector<int>     m_bunchtime;
    vector<int>     m_runFrom;
    vector<int>     m_runTo;
    vector<int>     m_eventFrom;
    vector<int>     m_eventTo;
  };
} // namespace CalibData
 
#endif // CalibData_EsTimeCalibData_h