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;
  }
 
}