TofCalibData.cxx

Go to the documentation of this file.

#include "CalibData/Tof/TofCalibData.h"
#include "CalibData/Tof/bTofCalibBase.h"
#include "CalibData/Tof/bTofCommonCalibBase.h"
#include "CalibData/Tof/eTofCalibBase.h"
#include "CalibData/Tof/etfCalibBase.h"
#include "GaudiKernel/MsgStream.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 )
      : m_bTofCalibData( bTofCal )
      , m_bTofCommonCalibData( bTofComCal )
      , m_eTofCalibData( eTofCal )
      , m_etfCalibData( etfCal )
      , m_etfBunchCalibData( etfBunchCal )
      , m_tofCalibInfoData( tofInfoCal )
      , m_hasEtf( etfCal.size() > 0 )
      , m_hasEtfBunch( etfBunchCal.size() > 0 ) {}
 
  TofCalibData::TofCalibData( std::vector<bTofCalibBase>       bTofCal,
                              std::vector<bTofCommonCalibBase> bTofComCal,
                              std::vector<eTofCalibBase>       eTofCal,
                              std::vector<etfCalibBase>        etfCal,
                              std::vector<tofCalibInfoBase>    tofInfoCal )
      : m_bTofCalibData( bTofCal )
      , m_bTofCommonCalibData( bTofComCal )
      , m_eTofCalibData( eTofCal )
      , m_etfCalibData( etfCal )
      , m_tofCalibInfoData( tofInfoCal )
      , m_hasEtf( etfCal.size() > 0 )
      , m_hasEtfBunch( false ) {}
 
  TofCalibData::TofCalibData( std::vector<bTofCalibBase>       bTofCal,
                              std::vector<bTofCommonCalibBase> bTofComCal,
                              std::vector<eTofCalibBase>       eTofCal,
                              std::vector<tofCalibInfoBase>    tofInfoCal )
      : m_bTofCalibData( bTofCal )
      , m_bTofCommonCalibData( bTofComCal )
      , m_eTofCalibData( eTofCal )
      , m_tofCalibInfoData( tofInfoCal )
      , m_hasEtf( false )
      , m_hasEtfBunch( false ) {}
 
  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 );
    m_bTofCalibData       = other1.m_bTofCalibData;
    m_bTofCommonCalibData = other1.m_bTofCommonCalibData;
    m_eTofCalibData       = other1.m_eTofCalibData;
    m_tofCalibInfoData    = other1.m_tofCalibInfoData;
 
    if ( other1.m_etfCalibData.size() > 0 )
    {
      m_etfCalibData = other1.m_etfCalibData;
      m_hasEtf       = true;
    }
    else
    {
      m_etfCalibData.clear();
      m_hasEtf = false;
    }
 
    if ( other1.m_etfBunchCalibData.size() > 0 )
    {
      m_etfBunchCalibData = other1.m_etfBunchCalibData;
      m_hasEtfBunch       = true;
    }
    else
    {
      m_etfBunchCalibData.clear();
      m_hasEtfBunch = false;
    }
 
    return StatusCode::SUCCESS;
  }
 
  // get the CalibData
  unsigned int TofCalibData::getBTofSize() const { return m_bTofCalibData.size(); }
 
  bTofCalibBase TofCalibData::getBTof( int cnt ) const { return m_bTofCalibData[cnt]; }
 
  int TofCalibData::getBTofComSize() const { return m_bTofCommonCalibData.size(); }
 
  bTofCommonCalibBase TofCalibData::getBTofCom( int cnt ) const {
    return m_bTofCommonCalibData[cnt];
  }
 
  unsigned int TofCalibData::getETofSize() const { return m_eTofCalibData.size(); }
 
  eTofCalibBase TofCalibData::getETof( int cnt ) const { return m_eTofCalibData[cnt]; }
 
  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 {
    auto 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 {
    auto 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 {
    auto 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 ) {
    return getETof( index ).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();
  }
 
} // namespace CalibData