MdcHvDropSvc.cxx

Go to the documentation of this file.

/**
 * @file MdcHvDropSvc.cxx
 * @author zhangzeheng (zhangzeheng@ihep.ac.cn)
 * @brief main functions of this svc
 * @version 0.1
 * @date 2022-01-19
 *
 * @copyright Copyright (c) 2022
 *
 */
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
 
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/StatusCode.h"
// #include "GaudiKernel/SvcFactory.h"
#include "MdcHvDropSvc.h"
 
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Incident.h"
 
#include "EventModel/Event.h"
#include "EventModel/EventHeader.h"
#include "EventModel/EventModel.h"
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/ISvcLocator.h"
 
#include <TMath.h>
 
// using namespace std;
using std::cout;
using std::endl;
using std::string;
 
DECLARE_COMPONENT( MdcHvDropSvc )
 
MdcHvDropSvc::MdcHvDropSvc( const string& name, ISvcLocator* svcloc )
    : base_class( name, svcloc ) {
  // declare properties
  declareProperty( "Host", m_host = std::string( "202.122.33.123" ) );
  declareProperty( "DbName", m_dbName = std::string( "tof40t_linux" ) );
  declareProperty( "TableName", m_table = std::string( "MDCLayerVmon" ) );
  declareProperty( "UserName", m_userName = std::string( "guest" ) );
  declareProperty( "Password", m_password = std::string( "guestpass" ) );
  declareProperty( "Port", m_port = 6175 );
  declareProperty( "IgnoreLayer_21_24", m_ignoreLayer_21_24 = true );
  declareProperty( "RelativeHvDropThreshold", m_relativeHvDropThreshold = 0.007 );
  declareProperty( "FetchHvDataLengthInSeconds", m_fetchLength = 5 * 3600 );
  declareProperty( "UseEtsT1", m_useEtsT1 = 0 ); // whether to use EtsT1, if not, use time().
  declareProperty( "EtsT1OffSet",
                   m_etsT1Offset = 0 ); // if is 0, and UseEtsT1,  will be treated as using
                                        // database time from database.. else, acts as
                                        // calculating time_override=etsT1+etsT1Offset;
 
  declareProperty( "Host2", m_host2 = std::string( "bes3db2.ihep.ac.cn" ) );
  declareProperty( "DbName2", m_dbName2 = std::string( "run" ) );
  declareProperty( "TableName2", m_table2 = std::string( "RunParams" ) );
  declareProperty( "UserName2", m_userName2 = std::string( "guest" ) );
  declareProperty( "Password2", m_password2 = std::string( "guestpass" ) );
  declareProperty( "Port2", m_port2 = 3306 ); // 3306 is default port for mysql
}
 
MdcHvDropSvc::~MdcHvDropSvc() {}
 
// StatusCode MdcHvDropSvc::queryInterface( const InterfaceID& riid, void** ppvInterface ) {
//   if ( IID_IMdcHvDropSvc.versionMatch( riid ) )
//   { *ppvInterface = static_cast<IMdcHvDropSvc*>( this ); }
//   else { return Service::queryInterface( riid, ppvInterface ); }
//   return StatusCode::SUCCESS;
// }
 
StatusCode MdcHvDropSvc::initialize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "MdcHvDropSvc::initialize()" << endmsg;
 
  StatusCode sc = Service::initialize();
  if ( sc.isFailure() ) return sc;
 
  IIncidentSvc* incsvc;
  sc           = service( "IncidentSvc", incsvc );
  int priority = 100;
  if ( sc.isSuccess() ) { incsvc->addListener( this, "NewRun", priority ); }
 
  sc = serviceLocator()->service( "EventDataSvc", m_eventSvc, true );
  if ( sc.isFailure() )
  {
    log << MSG::ERROR << "Unable to find EventDataSvc " << endmsg;
    return sc;
  }
 
  sc = initMySql();
  if ( sc.isFailure() )
  {
    log << MSG::ERROR << "Unable to initialize mysql " << endmsg;
    return sc;
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode MdcHvDropSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "MdcHvDropSvc::finalize()" << endmsg;
  //  if(m_connect_offline) delete m_connect_offline;
  return StatusCode::SUCCESS;
}
// TODO: multi-run.
void MdcHvDropSvc::handle( const Incident& inc ) {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "handle: " << inc.type() << endmsg;
  // so currently we do nothing.
  // if (inc.type() == "NewRun") {
  //    log << MSG::DEBUG << "NewRun" << endmsg;
  //
  //    SmartDataPtr<Event::EventHeader> eventHeader(m_eventSvc, "/Event/EventHeader");
  //    int run = eventHeader->runNumber();
  //    //cout<<"&&&&&&&&&&&&&&:&&&&&&&&&&&&&&&&&&&& MdcHvDropSvc handle,run="<<run<<endl;
  //    if (run < 0) run = -run;
  //    log << MSG::DEBUG << "handle: "
  //        << "Run in handle is: " << run << endmsg;
  //    cout << "-------------in MdcHvDropSvc in the following-----------" << endl;
  //    cout << "handle: "
  //         << "Run in handle is: " << run << endl;
 
  // if (run >= m_RunFrom && run <= m_RunTo && m_ReadPar == true) {
  //     cout << "do not read the database repeatly in EmcShEnCalibConst" << endl;
  //     cout << "run,RunFrom,runTo=" << run << "," << m_RunFrom << "," << m_RunTo << endl;
  // } else {
  //
  //     //cout<<"read the database in EmcShEnCalibConst"<<endl;
  //     if (!getMdcHvDropSvcInfo()) {
  //         log << MSG::ERROR << "can not initilize Shower energy Calib Constants" << endmsg;
  //     } else {
  //         m_ReadPar = true;
  //         std::cout << "in handle of MdcHvDropSvc  getPi0CalibFile()= " << getPi0CalibFile()
  //         << std::endl; std::cout << "getSingleGammaCalibFile()= " <<
  //         getSingleGammaCalibFile() << std::endl;
  //     }
  // }
  //}
}
 
/**
 * @brief connects to mysql using pre-defined parameters.
 *
 * @return StatusCode
 */
StatusCode MdcHvDropSvc::initMySql() {
  // char host    [] = "202.122.33.123";
  // char username[] = "guest";
  // char password[] = "guestpass";
  // int m_port  = 6175;
  // char database[] = "tof40t_linux";
  // char querystring[] = "select * from MDCLayerVmon where id >=1000000 and id <= 1000010";
 
  mysql_init( &m_mysql );
 
  if ( !mysql_real_connect( &m_mysql, m_host.c_str(), m_userName.c_str(), m_password.c_str(),
                            m_dbName.c_str(), m_port, NULL, 0 ) )
  {
    std::cerr << "Connect to database" << m_host << ":" << m_port << " failed\n"
              << "due to " << mysql_error( &m_mysql ) << std::endl;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}
 
/**
 * @brief timestamp to a string of the time in UTC+8
 *
 * from timestamp get sql formatted datetime string with TZ=UTC+8, or Asia/Shanghai
 * our Slow Control Database stores datetime with TZ=UTC+8,
 *
 * @param utctime timestamp
 * @param str the string to store
 * @param length length of string
 * @return size_t how many charactors are written to str (including trailing "\0"). basically
 * 0==fail, !0 == succeed.
 */
size_t MdcHvDropSvc::Time_t2str( Time_t utctime, char* str, int length ) {
  const int   tzOffset     = 60 * 60 * 8;
  std::time_t timeShanghai = utctime + tzOffset;
  std::tm*    tm           = std::gmtime( &timeShanghai );      // this is not thread safe
  return std::strftime( str, length, "%Y-%m-%d %H:%M:%S", tm ); // as-is
}
 
/**
 * @brief Get Time_t from a date_time string.
 * require str be like "%Y-%m-%d %H:%M:%S"
 * note that our date_time is fixed TZ=UTC+8, or Asia/Shanghai
 *
 * @param str date_time string
 * @return Time_t
 */
Time_t MdcHvDropSvc::datetimeStr2Time_t( const char* str ) {
  const int tzOffset = 60 * 60 * 8;
  std::tm   tm;
  int       year, month, day, hour, min, sec;
  std::sscanf( str, "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &min, &sec );
  tm.tm_year   = year - 1900;
  tm.tm_mon    = month - 1;
  tm.tm_mday   = day;
  tm.tm_hour   = hour;
  tm.tm_min    = min;
  tm.tm_sec    = sec;
  tm.tm_isdst  = 0;
  tm.tm_gmtoff = tzOffset;
  Time_t time  = std::mktime( &tm );
  return time;
}
 
/**
 * @brief fetch hv info from database between timeBegin and timeEnd. in DB time.
 *
 * @param timeBegin
 * @param timeEnd
 * @return StatusCode
 */
StatusCode MdcHvDropSvc::FetchHvInfo( Time_t timeBegin, Time_t timeEnd ) {
  // MsgStream log(msgSvc(), "MdcHvDropSvc");
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "MdcHvDropSvc::FetchHvInfo()" << endmsg;
  char querystring[300];
  char sTimeBegin[100], sTimeEnd[100];
  Time_t2str( timeBegin, sTimeBegin, 100 );
  Time_t2str( timeEnd, sTimeEnd, 100 );
  // MYSQL_RES *res_set;
 
  sprintf( querystring, "select * \
        from %s \
        where date_time >= '%s' \
        and date_time <= '%s' ",
           m_table.c_str(), sTimeBegin, sTimeEnd );
  log << MSG::INFO << "sql_request=" << querystring << endmsg;
  // yield:
 
  // unsigned int nColomn;
 
  if ( mysql_query( &m_mysql, querystring ) )
  {
    log << MSG::ERROR << "Error! mysql_query failed" << endmsg;
    return StatusCode::FAILURE;
  }
  else
  {
    m_result = mysql_store_result( &m_mysql );
    // nColomn = mysql_num_fields(m_result);
    while ( ( m_row = mysql_fetch_row( m_result ) ) )
    {
      // unsigned long *lengths;
      // lengths = mysql_fetch_lengths(m_result);
 
      VDataItem item;
      Time_t    time;
      sqlRow2Item( m_row, m_result, item, time ).ignore();
      m_vData.push_back_sorted( time, item );
 
      // for (int i = 0; i < nColomn; i++) {
      //     printf("[%.*s] \t", (int)lengths[i], m_row[i] ? //m_row[i] : "NULL");
      //     item[]
      //
      //}
      // printf("\n");
    }
    log << MSG::INFO << "successfully fetched HV data from database." << endmsg;
  }
 
  return StatusCode::SUCCESS;
}
/**
 * @brief returns average HV for a slice in a row, row[begin:end]
 *
 * contain row[sliceBegin];
 * contains no row[sliceEnd];
 */
inline static double average( MYSQL_ROW row, int sliceBegin, int sliceEnd ) {
 
  double sum = 0.0;
  for ( int i = sliceBegin; i < sliceEnd; i++ ) { sum += atof( row[i] ); }
  return sum / ( sliceEnd - sliceBegin );
}
 
/**
 * @brief grab info stored in a row of mysql result, and build a VDataItem from it. also time.
 *
 * @param row
 * @param result
 * @param item the item
 * @param time
 * @return StatusCode
 */
StatusCode MdcHvDropSvc::sqlRow2Item( MYSQL_ROW row, MYSQL_RES* result, VDataItem& item,
                                      Time_t& time ) {
  // VDataItem&  item=out;
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "MdcHvDropSvc::sqlRow2Item()" << endmsg;
  int nColomn = mysql_num_fields( result );
  if ( nColomn != 102 )
  {
    log << MSG::ERROR << "ERROR: SQL output does not meet expectation" << endmsg;
    return StatusCode::FAILURE;
  }
  // unsigned long *lengths;
  // lengths = mysql_fetch_lengths(result);
  time    = datetimeStr2Time_t( row[1] );
  item[0] = average( row, 39, 44 ); // S1
  item[1] = average( row, 44, 50 ); // S2
  item[2] = average( row, 50, 56 ); // S3
  item[3] = average( row, 56, 62 ); // S4
  item[4] = atof( row[80] );        // S5
  item[5] = atof( row[81] );        // S6
  for ( int i = 2; i < 39; i++ )
  {
    int layer   = i + 4;
    item[layer] = atof( row[i] ); // S7~43
  }
  return StatusCode::SUCCESS;
 
  // from
  // ia[:,2:39].astype(float)#S7-43
}
 
double MdcHvDropSvc::queryRelativeHvDrop() {
  MsgStream log( msgSvc(), name() );
  // log << MSG::DEBUG << "MdcHvDropSvc::sqlRow2Item()" << endmsg;
  SmartDataPtr<Event::EventHeader> eventHeader( m_eventSvc, "/Event/EventHeader" );
  Time_t                           time           = eventHeader->time();
  Time_t                           fetchBeginTime = time;
  int                              run            = eventHeader->runNumber();
  unsigned long                    time_etsT1     = eventHeader->etsT1();
  long time_etsT1_timelike32 = ( ( time_etsT1 / 2000000 ) & 0x00000000ffffffffLU );
 
  // handle etsT1 logic
  //    declareProperty("UseEtsT1",m_useEtsT1=0); // whether to use EtsT1, if not, use time().
  // declareProperty("EtsT1OffSet",m_etsT1Offset=0);// if is 0, and UseEtsT1,  will be treated
  // as using database time from database.. else, acts as calculating
  // time_override=etsT1+etsT1Offset;
 
  if ( m_useEtsT1 )
  {
 
    if ( m_etsT1Offset == 0 ) { time = time_etsT1_timelike32 + getRunBeginTime( run ); }
    else { time = time_etsT1_timelike32 + m_etsT1Offset; }
  }
 
  if ( run < 0 ) return 0; // a MC event.
 
  log << MSG::INFO << "query time " << time << endmsg;
  log << MSG::INFO << "current boundary " << m_vData.getLowerBoundaryEventTime() << " : "
      << m_vData.getUpperBoundaryEventTime() << endmsg;
 
  if ( m_vData.getUpperBoundaryEventTime() < time ||
       time < m_vData.getLowerBoundaryEventTime() )
  { // not in cache
    // 1st time.
    if ( m_vData.size() == 0 )
    {
      char time1str[100];
      Time_t2str( time, time1str, 100 );
      log << MSG::INFO << "INFO: MdcHvDropSvc time " << time << " aka " << time1str
          << " is not in cache yet.\n"
          << "\tfetching HV info for 1h ago" << time - 3600 << " til fetch Length"
          << time + m_fetchLength - 3600 << endmsg;
      fetchBeginTime = time - 3600;
    }
    // 2nd time
    else
    {
      Time_t upTimeCachedDBTime =
          m_vData.getUpperBoundaryEventTime() + m_vData.getOffsetEvt2Db();
      char time1str[100];
      Time_t2str( time, time1str, 100 );
      // time in another fetch interval, thus we choose to fetch new data and append to cache
      if ( m_vData.getLowerBoundaryEventTime() < time &&
           time < m_vData.getUpperBoundaryEventTime() + m_fetchLength )
      {
 
        log << MSG::INFO << "INFO:MdcHvDropSvc time " << time << " aka " << time1str
            << " is not in cache yet.\n"
            << "\tcurrent upperBoundary is " << m_vData.getUpperBoundaryEventTime() << "\n"
            << "\tfetching HV info for dbTime " << upTimeCachedDBTime
            << " to fetch Length later" << upTimeCachedDBTime + m_fetchLength << endmsg;
        fetchBeginTime = upTimeCachedDBTime;
      }
      // time not in another fetch interval, and we cannot find a interval to append to cache.
      else
      {
        log << MSG::INFO << "INFO:MdcHvDropSvc time " << time << " aka " << time1str
            << " is not in cache or canbe fetched in a interval.\n"
            << "\tcurrent cache boundary is " << m_vData.getLowerBoundaryEventTime() << ":"
            << m_vData.getUpperBoundaryEventTime() << ".\n"
            << "\tcurrent fetch interval is " << m_vData.getUpperBoundaryEventTime() << ":"
            << m_vData.getUpperBoundaryEventTime() + m_fetchLength << endmsg;
        log << MSG::INFO << "aborted cache and fetching new data.\n"
            << "\tfetching HV info for 1h ago" << time - 3600 << " til fetch Length"
            << time + m_fetchLength - 3600 << endmsg;
        m_vData.clear();
        fetchBeginTime = time - 3600;
      }
    }
 
    fetchBeginTime += m_vData.getOffsetEvt2Db(); // now db time
    Time_t time2 = fetchBeginTime + m_fetchLength;
    if ( !FetchHvInfo( fetchBeginTime - 600, time2 ).isSuccess() )
    {
      cout << "ERROR: MdcHvDropSvc failed to fetch HV info\n";
      return -10000;
    }
  }
  if ( !m_vData.isValid( time ) ) return -9999;
  if ( m_ignoreLayer_21_24 ) return m_vData.getAvgDropButVeryDrop( time );
  else return m_vData.getAvgDrop( time );
}
 
Time_t MdcHvDropSvc::getRunBeginTime( int runid ) {
 
  if ( m_run_begin.find( runid ) != m_run_begin.end() ) { return m_run_begin[runid]; }
  // connect to offline database
  MYSQL      mysql;
  MYSQL_ROW  row;
  MYSQL_RES* result;
  mysql_init( &mysql );
  const Time_t ret_err = 0;
 
  if ( !mysql_real_connect( &mysql, m_host2.c_str(), m_userName2.c_str(), m_password2.c_str(),
                            m_dbName2.c_str(), m_port2, NULL, 0 ) )
  {
    std::cerr << "Connect to database" << m_host << ":" << m_port << " failed\n"
              << "due to " << mysql_error( &mysql ) << std::endl;
    return m_run_begin[runid] = ret_err;
  }
  char querystring[300];
  // query is        SELECT run_number, startTime, endTime        FROM RunParams        WHERE
  // run_number >= %s AND run_number <= %s
  sprintf( querystring,
           "SELECT run_number, startTime, endTime FROM RunParams WHERE run_number = %d",
           runid );
  if ( mysql_query( &mysql, querystring ) )
  {
    std::cerr << "Error! mysql_query failed" << std::endl;
    return m_run_begin[runid] = ret_err;
  }
  else
  {
    result = mysql_store_result( &mysql );
    if ( mysql_num_rows( result ) < 1 )
    {
      std::cerr << "Error! mysql_query returns " << mysql_num_rows( result ) << " rows"
                << std::endl;
      return m_run_begin[runid] = ret_err;
    }
    row         = mysql_fetch_row( result );
    Time_t time = datetimeStr2Time_t( row[1] );
    mysql_free_result( result );
    mysql_close( &mysql );
    std::cout << "got run begin time for run " << runid << " is " << time << std::endl;
    return m_run_begin[runid] = time;
  }
}