MdcHvDropSvc.cxx

Go to the documentation of this file.

/**
 * @file MdcHvDropSvc.cxx
 * @author zhangzeheng ([email protected])
 * @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/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) : Service(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(messageService(), name());
    log << MSG::INFO << "MdcHvDropSvc::initialize()" << endreq;
 
    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("DatabaseSvc", m_dbsvc, true);
    //if (sc.isFailure()) {
    //    log << MSG::ERROR << "Unable to find DatabaseSvc " << endreq;
    //    return sc;
    //}
//
    sc = serviceLocator()->service("EventDataSvc", m_eventSvc, true);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Unable to find EventDataSvc " << endreq;
        return sc;
    }
 
    sc = initMySql();
    if (sc.isFailure()){
        log << MSG::ERROR << "Unable to initialize mysql " << endreq;
        return sc;
    }
 
    return StatusCode::SUCCESS;
}
 
StatusCode MdcHvDropSvc::finalize() {
    MsgStream log(messageService(), name());
    log << MSG::INFO << "MdcHvDropSvc::finalize()" << endreq;
    //  if(m_connect_offline) delete m_connect_offline;
    return StatusCode::SUCCESS;
}
// TODO: multi-run.
void MdcHvDropSvc::handle(const Incident &inc) {
    MsgStream log(messageService(), name());
    log << MSG::DEBUG << "handle: " << inc.type() << endreq;
    // so currently we do nothing.
    //if (inc.type() == "NewRun") {
    //    log << MSG::DEBUG << "NewRun" << endreq;
    //
    //    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 << endreq;
    //    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" << endreq;
        //    } 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(messageService(), name());
    log << MSG::INFO << "MdcHvDropSvc::FetchHvInfo()" << endreq;
    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 << endreq;
    // yield:
 
    //unsigned int nColomn;
 
    if (mysql_query(&m_mysql,querystring)){
        log << MSG::ERROR << "Error! mysql_query failed"<<endreq;
        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);
            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." << endreq;
    }
 
 
 
    //int row_no = m_dbsvc->query(dbName.c_str(), stmt, res);
    //if (row_no < 1) {
    //    std::cerr << "ERROR: query" << stmt << "returns empty //result"<<std::endl;
    //}
    //else {
    //    for (int i = 0; i < row_no; i++) {
    //        DatabaseRecord *records1 = res[i];
    //        VDataItem item;
    //        runfrm                   = records1->GetInt("RunFrom");
    //        runto                    = records1->GetInt("RunTo");
//
//
    //        SftVer    = records1->GetString("SftVer");
    //        CalParVer = records1->GetString("ParVer");
//
    //    }
//
    //}
 
    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(messageService(), name());
    log << MSG::DEBUG << "MdcHvDropSvc::sqlRow2Item()" << endreq;
    int nColomn = mysql_num_fields(result);
    if (nColomn !=102){
        log << MSG::ERROR << "ERROR: SQL output does not meet expectation"<<endreq;
        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
 
}
 
//bool MdcHvDropSvc::getMdcHvDropSvcInfo() {
//    MsgStream log(messageService(), name());
//    SmartDataPtr<Event::EventHeader> eventHeader(m_eventSvc, "/Event/EventHeader");
//    int run = eventHeader->runNumber();
//    cout << "Run in getMdcHvDropSvcInfo() is: " << run << endl;
//
//    char stmt1[400];
//    StatusCode st1;
//    //runfrm,runto are the value from the table ***CalConst;runfrm1,runto1 are the value from the table CalVtxLumVer
//    int runfrm, runfrm1;
//    int runto, runto1;
//    std::string cType;
//
//    if (run < 0) {
//        cout << "This data is the MC sample with the Run Number: " << run << endl;
//        run = -run;
//    }
//
//    if (m_bossRelease == "default") m_bossRelease = getenv("BES_RELEASE");
//
//    cType = "EmcShEnCalib";
//
//    st1 = getSftParVer(m_bossVer, m_calPar, runfrm1, runto1, run, m_bossRelease, cType);
//
//    sprintf(stmt1, "select  RunFrom,RunTo,singleGammaCalib,pi0Calib from EmcShEnCalibConst where SftVer = '%s' and //RunFrom <= %d and RunTo >= %d ", m_bossVer.c_str(), run, run);
//
//    DatabaseRecordVector res;
//    int row_no = m_dbsvc->query("offlinedb", stmt1, res);
//
//    if (row_no > 0) {
//        DatabaseRecord &dbrec  = *res[row_no - 1];
//        m_SingleGammaCalibFile = dbrec.GetString("singleGammaCalib");
//        m_Pi0CalibFile         = dbrec.GetString("pi0Calib");
//        m_RunFrom              = dbrec.GetInt("RunFrom");
//        m_RunTo                = dbrec.GetInt("RunTo");
//
//        cout << "BossReleaseVer=" << m_bossRelease.c_str() << "\t"
//             << "EmcShEnCalibBossVer=" << m_bossVer.c_str() << endl;
//        cout << "m_Pi0CalibFile is:" << m_Pi0CalibFile << endl;
//        cout << "m_SingleGammaCalibFile is:" << m_SingleGammaCalibFile << endl;
//        cout << "m_RunFrom is:" << m_RunFrom << endl;
//        cout << "m_RunTo is:" << m_RunTo << endl;
//        cout << "Successfully fetch MdcHvDropSvc information for run: " << run << endl;
//        cout << "////////// read parameters from EmcShEnCalibConst database/////////////" << endl;
//        return true;
//    } else if (row_no <= 0) {
//        cout << " MdcHvDropSvc:: can not found MdcHvDropSvc information of run:"
//             << run << ", boss version " << m_bossRelease << endl;
//        exit(1);
//        return false;
//    }
//    return true;
//}
 
double MdcHvDropSvc::queryRelativeHvDrop() {
    MsgStream log(messageService(), name());
    //log << MSG::DEBUG << "MdcHvDropSvc::sqlRow2Item()" << endreq;
    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 << endreq;
    log << MSG::INFO << "current boundary " << m_vData.getLowerBoundaryEventTime() << " : " << m_vData.getUpperBoundaryEventTime() << endreq;
 
    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 << endreq;
            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 << endreq;
                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 << endreq;
                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 << endreq;
                m_vData.clear();
                fetchBeginTime = time - 3600;
            }
        }
 
        fetchBeginTime += m_vData.getOffsetEvt2Db(); // now db time
        Time_t time2 = fetchBeginTime + m_fetchLength;
        if (!FetchHvInfo(fetchBeginTime - 600, time2) == StatusCode::SUCCESS) {
            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;
    }
 
}