TofCalibData.cxx

Go to the documentation of this file.

#include "GaudiKernel/MsgStream.h"
#include "CalibData/Tof/bTofCalibBase.h"
#include "CalibData/Tof/bTofCommonCalibBase.h"
#include "CalibData/Tof/eTofCalibBase.h"
#include "CalibData/Tof/etfCalibBase.h"
#include "CalibData/Tof/TofCalibData.h"
 
namespace CalibData {
 
  TofCalibData::TofCalibData(std::vector<bTofCalibBase>* bTofCal,std::vector<bTofCommonCalibBase>* bTofComCal,std::vector<eTofCalibBase>* eTofCal,std::vector<etfCalibBase>* etfCal,std::vector<etfBunchCalibBase>* etfBunchCal,std::vector<tofCalibInfoBase>* tofInfoCal){
    if(bTofCal){
      m_bTofCalibData = new std::vector<bTofCalibBase>(*bTofCal);
    }
    if(bTofComCal){
      m_bTofCommonCalibData = new std::vector<bTofCommonCalibBase>(*bTofComCal);
    }
    if(eTofCal){
      m_eTofCalibData = new std::vector<eTofCalibBase>(*eTofCal);
    }
 
    m_hasEtf = false;
    m_etfCalibData = NULL;
    if( etfCal->size() > 0  ) {
      m_hasEtf = true;
      m_etfCalibData = new std::vector<etfCalibBase>(*etfCal);
    }
    m_hasEtfBunch = false;
    m_etfBunchCalibData = NULL;
    if( etfBunchCal->size() > 0  ) {
      m_hasEtfBunch = true;
      m_etfBunchCalibData = new std::vector<etfBunchCalibBase>(*etfBunchCal);
    }
 
    if(tofInfoCal){
      m_tofCalibInfoData = new std::vector<tofCalibInfoBase>(*tofInfoCal);
    }
  }
     
  TofCalibData::TofCalibData(std::vector<bTofCalibBase>* bTofCal,std::vector<bTofCommonCalibBase>* bTofComCal,std::vector<eTofCalibBase>* eTofCal,std::vector<etfCalibBase>* etfCal,std::vector<tofCalibInfoBase>* tofInfoCal){
    if(bTofCal){
      m_bTofCalibData = new std::vector<bTofCalibBase>(*bTofCal);
    }
    if(bTofComCal){
      m_bTofCommonCalibData = new std::vector<bTofCommonCalibBase>(*bTofComCal);
    }
    if(eTofCal){
      m_eTofCalibData = new std::vector<eTofCalibBase>(*eTofCal);
    }
 
    m_hasEtf = false;
    m_etfCalibData = NULL;
    if( etfCal->size() > 0  ) {
      m_hasEtf = true;
      m_etfCalibData = new std::vector<etfCalibBase>(*etfCal);
    }
    m_hasEtfBunch = false;
    m_etfBunchCalibData = NULL;
 
    if(tofInfoCal){
      m_tofCalibInfoData = new std::vector<tofCalibInfoBase>(*tofInfoCal);
    }
  }
     
  TofCalibData::TofCalibData(std::vector<bTofCalibBase>* bTofCal,std::vector<bTofCommonCalibBase>* bTofComCal,std::vector<eTofCalibBase>* eTofCal,std::vector<tofCalibInfoBase>* tofInfoCal){
    if(bTofCal){
      m_bTofCalibData = new std::vector<bTofCalibBase>(*bTofCal);
    }
    if(bTofComCal){
      m_bTofCommonCalibData = new std::vector<bTofCommonCalibBase>(*bTofComCal);
    }
    if(eTofCal){
      m_eTofCalibData = new std::vector<eTofCalibBase>(*eTofCal);
    }
    if(tofInfoCal){
      m_tofCalibInfoData = new std::vector<tofCalibInfoBase>(*tofInfoCal);
    }
    m_hasEtf            = false;
    m_etfCalibData      = NULL;
    m_hasEtfBunch       = false;
    m_etfBunchCalibData = NULL;
  }
 
  StatusCode TofCalibData::update(CalibBase1& other, MsgStream* log)
  {
    TofCalibData& other1 = dynamic_cast<TofCalibData& >(other);
    std::cout<<"========================================"<<"\n"<<"here is the update in the TofCalibData"<<"\n"<<"========================================"<<std::endl;
    CalibBase1::update(other, log);
    delete m_bTofCalibData;
    m_bTofCalibData = new std::vector<bTofCalibBase>(*(other1.m_bTofCalibData));
    delete m_bTofCommonCalibData;
    m_bTofCommonCalibData = new std::vector<bTofCommonCalibBase>(*(other1.m_bTofCommonCalibData));
    delete m_eTofCalibData;
    m_eTofCalibData = new std::vector<eTofCalibBase>(*(other1.m_eTofCalibData));
    delete m_tofCalibInfoData;
    m_tofCalibInfoData = new std::vector<tofCalibInfoBase>(*(other1.m_tofCalibInfoData));
 
    if( m_etfCalibData ) { delete m_etfCalibData; }
    if( other1.m_etfCalibData ) {
      if( (other1.m_etfCalibData)->size() > 0 ) {
    m_etfCalibData = new std::vector<etfCalibBase>(*(other1.m_etfCalibData));
    m_hasEtf = true;
      }
    }
    else {
      m_etfCalibData = NULL;
      m_hasEtf = false;
    }
 
    if( m_etfBunchCalibData ) { delete m_etfBunchCalibData; }
    if( other1.m_etfBunchCalibData ) {
      if( (other1.m_etfBunchCalibData)->size() > 0 ) {
    m_etfBunchCalibData = new std::vector<etfBunchCalibBase>(*(other1.m_etfBunchCalibData));
    m_hasEtfBunch = true;
      }
    }
    else {
      m_etfBunchCalibData = NULL;
      m_hasEtfBunch = false;
    }
 
    return StatusCode::SUCCESS;  
  } 
 
  //get the CalibData
  unsigned int TofCalibData::getBTofSize() const{
    return m_bTofCalibData->size();
  }
 
  bTofCalibBase TofCalibData::getBTof(int cnt) const{
    std::vector<bTofCalibBase>::iterator it = m_bTofCalibData->begin();
    for(int i=0;i!=cnt;i++,it++) {  
    }
    return *it;
  }
 
  int TofCalibData::getBTofComSize() const{
    return m_bTofCommonCalibData->size();
  }
 
  bTofCommonCalibBase TofCalibData::getBTofCom(int cnt) const{
    std::vector<bTofCommonCalibBase>::iterator it = m_bTofCommonCalibData->begin();
    for(int i=0;i!=cnt;i++,it++) {  
    }
    return *it;
  }
 
  unsigned int TofCalibData::getETofSize() const{
    return m_eTofCalibData->size();
  }
 
  eTofCalibBase TofCalibData::getETof(int cnt) const{
    std::vector<eTofCalibBase>::iterator it = m_eTofCalibData->begin();
    for(int i=0;i!=cnt;i++,it++) {  
    }
    return *it;
  }
 
  unsigned int TofCalibData::getEtfSize() const{
    unsigned int size = 72*12;
    if( m_hasEtf ) {
      size = m_etfCalibData->size();
    }
    return size;
  }
 
  etfCalibBase TofCalibData::getEtf(int cnt,int strip) const{
    std::vector<etfCalibBase>::iterator it = m_etfCalibData->begin();
    for(int i=0;i!=cnt;i++) {  
      for( int j=0;j!=12;j++,it++) {
      }
    }
    for( int j=0;j!=strip;j++,it++) {
    }
    return *it;
  }
 
  unsigned int TofCalibData::getEtfBunchSize() const{
    unsigned int size = 0;
    if( m_hasEtfBunch ) {
      size = m_etfBunchCalibData->size();
    }
    return size;
  }
 
  etfBunchCalibBase TofCalibData::getEtfBunch(int cnt) const{
    std::vector<etfBunchCalibBase>::iterator it = m_etfBunchCalibData->begin();
    for(int i=0;i!=cnt;i++,it++) {  
    }
    return *it;
  }
 
  unsigned int TofCalibData::getTofInfoSize() const{
    return m_tofCalibInfoData->size();
  }
 
  tofCalibInfoBase TofCalibData::getTofInfo(int cnt) const{
    std::vector<tofCalibInfoBase>::iterator it = m_tofCalibInfoData->begin();
    for(int i=0;i!=cnt;i++,it++) {  
    }
    return *it;
  }
 
  double TofCalibData::getBTofAtten(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return  bTof.getAtten(pardex);
  }
 
  double TofCalibData::getBTofSpeed(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return  bTof.getSpeed(pardex);
  }
 
  double TofCalibData::getBTofPleft(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getP1(pardex);
  }
 
  double TofCalibData::getBTofPright(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getP2(pardex);
  }
 
  double TofCalibData::getBTofPoffleft_bunch0(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff1_bunch0(pardex);
  }
 
  double TofCalibData::getBTofPoffright_bunch0(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff2_bunch0(pardex);
  }
 
  double TofCalibData::getBTofPoffleft_bunch1(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff1_bunch1(pardex);
  }
  
  double TofCalibData::getBTofPoffright_bunch1(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff2_bunch1(pardex);
  } 
 
  double TofCalibData::getBTofPoffleft_bunch2(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff1_bunch2(pardex);
  }
  
  double TofCalibData::getBTofPoffright_bunch2(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff2_bunch2(pardex);
  }
 
  double TofCalibData::getBTofPoffleft_bunch3(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff1_bunch3(pardex);
  }
 
  double TofCalibData::getBTofPoffright_bunch3(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getPoff2_bunch3(pardex);
  }
 
  double TofCalibData::getBTofFleft(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getFleft(pardex);
  }
 
  double TofCalibData::getBTofFright(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getFright(pardex);
  }
 
  double TofCalibData::getBTofFcounter(int index,int pardex){
    bTofCalibBase bTof = getBTof(index);
    return bTof.getFcounter(pardex);
  }
 
  double TofCalibData::getBTofOffset(int cnt, int pardex){
    bTofCommonCalibBase bTofCom = getBTofCom(cnt);
    return bTofCom.getOffset(pardex);
  }
 
  double TofCalibData::getBTofSigmaCorr(int cnt, int pardex){
    bTofCommonCalibBase bTofCom = getBTofCom(cnt);
    return bTofCom.getSigmaCorr(pardex);
  }
 
  double TofCalibData::getETofAtten(int index,int pardex){
    eTofCalibBase eTof = getETof(index);
    return  eTof.getAtten(pardex);
  }
 
  double TofCalibData::getETofSpeed(int index,int pardex){
    eTofCalibBase eTof = getETof(index);
    return  eTof.getSpeed(pardex);
  }
 
  double TofCalibData::getETofP(int index,int pardex){
    eTofCalibBase eTof = getETof(index);
    return eTof.getP(pardex);
  }
 
  double TofCalibData::getETofFP(int index,int pardex){
    eTofCalibBase eTof = getETof(index);
    return eTof.getFP(pardex);
  }
 
  double TofCalibData::getEtfSpeed(int index,int strip,int pardex){
    if( !m_hasEtf ) { return 1.0; }
    etfCalibBase etf = getEtf(index,strip);
    return etf.getSpeed(pardex);
  }
 
  double TofCalibData::getEtfPcombine(int index,int strip,int pardex){
    if( !m_hasEtf ) { return 1.0; }
    etfCalibBase etf = getEtf(index,strip);
    return etf.getP(pardex);
  }
 
  double TofCalibData::getEtfPleft(int index,int strip,int pardex){
    if( !m_hasEtf ) { return 1.0; }
    etfCalibBase etf = getEtf(index,strip);
    return etf.getP1(pardex);
  }
 
  double TofCalibData::getEtfPright(int index,int strip,int pardex){
    if( !m_hasEtf ) { return 1.0; }
    etfCalibBase etf = getEtf(index,strip);
    return etf.getP2(pardex);
  }
 
  double TofCalibData::getEtfPBunch(int cnt, int pardex){
    if( !m_hasEtfBunch ) { return 0.0; }
    etfBunchCalibBase etfBunch = getEtfBunch(cnt);
    return etfBunch.getPBunch(pardex);
  }
 
  int TofCalibData::getRunBegin(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getRunBegin();
  }
 
  int TofCalibData::getRunEnd(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getRunEnd();
  }
 
  int TofCalibData::getVersion(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getVersion();
  }
 
  int TofCalibData::getQCorr(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getQCorr();
  }
 
  int TofCalibData::getQElec(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getQElec();
  }
 
  int TofCalibData::getMisLable(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getMisLable();
  }
 
  int TofCalibData::getBrEast(int cnt, int index){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getBrEast(index);
  }
 
  int TofCalibData::getBrWest(int cnt, int index){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getBrWest(index);
  }
 
  int TofCalibData::getEndcap(int cnt, int index){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getEndcap(index);
  }
 
  int TofCalibData::getRunFrom(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getRunFrom();
  }
 
  int TofCalibData::getRunTo(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getRunTo();
  }
 
  int TofCalibData::getEventFrom(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getEventFrom();
  }
 
  int TofCalibData::getEventTo(int cnt){
    tofCalibInfoBase tofInfo = getTofInfo(cnt);
    return tofInfo.getEventTo();
  }
 
}