EsTimeCalibData.cxx

Go to the documentation of this file.

/** @class EsTimeCalibData
 *    Implementation of EsTimeCalibData calibration TCDS class
 */
 
#include "CalibData/EsTime/EsTimeCalibData.h"
#include "GaudiKernel/MsgStream.h"
namespace CalibData {
  EsTimeCalibData::EsTimeCalibData() : m_TestCalibConst( 0 ) {
    //    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;
  }
 
  StatusCode EsTimeCalibData::update( CalibBase1& other, MsgStream* log ) {
    EsTimeCalibData& other1 = dynamic_cast<EsTimeCalibData&>( other );
    std::cout << "========================================"
              << "\n"
              << "here is the update in the EsTimeCalibData"
              << "\n"
              << "==================================================" << std::endl;
    CalibBase1::update( other, log );
    // set the Calibration Data
    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(); }
 
    m_TestCalibConst = new vector<double>( *other1.m_TestCalibConst );
    m_toffsetb       = other1.m_toffsetb;
    m_toffsete       = other1.m_toffsete;
    m_bunchtime      = other1.m_bunchtime;
    m_runFrom        = other1.m_runFrom;
    m_runTo          = other1.m_runTo;
    m_eventFrom      = other1.m_eventFrom;
    m_eventTo        = other1.m_eventTo;
 
    return StatusCode::SUCCESS;
  }
 
  // set the Calibdata of EsTime
  void EsTimeCalibData::setTestCalibConst( const vector<double>* TestCalibConst ) {
    if ( m_TestCalibConst ) delete m_TestCalibConst;
    m_TestCalibConst = new vector<double>( *TestCalibConst );
  }
 
  // set time of offset
  void EsTimeCalibData::setToffsetb( const double toffset ) {
    m_toffsetb.push_back( toffset );
    return;
  }
 
  void EsTimeCalibData::setToffsete( const double toffset ) {
    m_toffsete.push_back( toffset );
    return;
  }
 
  // set the time interval of each bunch
  void EsTimeCalibData::setBunchTime( const int bunchtime ) {
    m_bunchtime.push_back( bunchtime );
    return;
  }
 
  void EsTimeCalibData::setRunFrom( const int runFrom ) {
    m_runFrom.push_back( runFrom );
    return;
  }
 
  void EsTimeCalibData::setRunTo( const int runTo ) {
    m_runTo.push_back( runTo );
    return;
  }
 
  void EsTimeCalibData::setEventFrom( const int eventFrom ) {
    m_eventFrom.push_back( eventFrom );
    return;
  }
 
  void EsTimeCalibData::setEventTo( const int eventTo ) {
    m_eventTo.push_back( eventTo );
    return;
  }
 
  double EsTimeCalibData::getToffsetb() { return getToffsetb( 0 ); }
 
  double EsTimeCalibData::getToffsetb( unsigned int No ) {
    double toffsetb = 0.0;
    if ( m_toffsetb.size() != 0 )
    {
      vector<double>::iterator it = m_toffsetb.begin() + No;
      toffsetb                    = ( *it );
    }
    return toffsetb;
  }
 
  double EsTimeCalibData::getToffsete() { return getToffsete( 0 ); }
 
  double EsTimeCalibData::getToffsete( unsigned int No ) {
    double toffsete = 0.0;
    if ( m_toffsete.size() != 0 )
    {
      vector<double>::iterator it = m_toffsete.begin() + No;
      toffsete                    = ( *it );
    }
    return toffsete;
  }
 
  double EsTimeCalibData::getBunchTime() { return getBunchTime( 0 ); }
 
  double EsTimeCalibData::getBunchTime( unsigned int No ) {
    double bunchtime = 0.0;
    if ( m_bunchtime.size() != 0 )
    {
      vector<int>::iterator it = m_bunchtime.begin() + No;
      bunchtime                = ( *it );
    }
    return bunchtime;
  }
 
  int EsTimeCalibData::getRunFrom() { return getRunFrom( 0 ); }
 
  int EsTimeCalibData::getRunFrom( unsigned int No ) {
    int runFrom = 0.0;
    if ( m_runFrom.size() != 0 )
    {
      vector<int>::iterator it = m_runFrom.begin() + No;
      runFrom                  = ( *it );
    }
    return runFrom;
  }
 
  int EsTimeCalibData::getRunTo() { return getRunTo( 0 ); }
 
  int EsTimeCalibData::getRunTo( unsigned int No ) {
    int runTo = 0.0;
    if ( m_runTo.size() != 0 )
    {
      vector<int>::iterator it = m_runTo.begin() + No;
      runTo                    = ( *it );
    }
    return runTo;
  }
 
  int EsTimeCalibData::getEventFrom( unsigned int No ) {
    int eventFrom = 0.0;
    if ( m_eventFrom.size() != 0 )
    {
      vector<int>::iterator it = m_eventFrom.begin() + No;
      eventFrom                = ( *it );
    }
    return eventFrom;
  }
 
  int EsTimeCalibData::getEventTo() { return getEventTo( 0 ); }
 
  int EsTimeCalibData::getEventTo( unsigned int No ) {
    int eventTo = 0.0;
    if ( m_eventTo.size() != 0 )
    {
      vector<int>::iterator it = m_eventTo.begin() + No;
      eventTo                  = ( *it );
    }
    return eventTo;
  }
 
} // namespace CalibData