MeasuredEcmsSvc.cxx

Go to the documentation of this file.

/***********************************************************************
 * BES III Software                                                    *
 * Copyright(C) - BES III Collaboration                                *
 *                                                                     *
 * Author: The BESIII Collaboration                                    *
 * Contributor: Lianjin Wu                                             *
 *                                                                     *
 ***********************************************************************/
 
#include "MeasuredEcmsSvc/MeasuredEcmsSvc.h"
 
using namespace std;
 
DECLARE_COMPONENT(MeasuredEcmsSvc)
// Constructor
MeasuredEcmsSvc::MeasuredEcmsSvc(const std::string &name, ISvcLocator *svcLoc) : base_class(name, svcLoc)
{
  // declare properties
  declareProperty("ReadOneTime", m_readOneTime=false);
  declareProperty("RunFrom", m_runFrom=8093);
  declareProperty("RunTo", m_runTo=9025);
  m_runflag = -1;
}
 
// Destructor
MeasuredEcmsSvc::~MeasuredEcmsSvc()
{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "destructor" << endreq;
}
 
// Initialize
StatusCode MeasuredEcmsSvc::initialize()
{
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "initialize begin here" << endreq;
 
  StatusCode status = Service::initialize();
  if (! status.isSuccess()) {
    log << MSG::ERROR << "can not initialize" << endreq;
    return status;
  }
  IIncidentSvc *incsvc;
  status = service("IncidentSvc", incsvc);
  int priority = 100;
  if (status.isSuccess()) incsvc->addListener(this, "NewRun", priority);
 
  status = serviceLocator()->service("DatabaseSvc", m_dbSvc, true);
  if (! status.isSuccess()) {
    log << MSG::ERROR<< "unable to find DatabaseSvc" << endreq;
    return status;
  }
 
  status = serviceLocator()->service("EventDataSvc", m_eventSvc, true);
  if (! status.isSuccess()) {
    log << MSG::ERROR << "unable to find EventDataSvc " << endreq;
    return status;
  }
  if(m_readOneTime){
    if(m_runFrom>=8093){
        readDBTable(m_runFrom, m_runTo);
    }
    else
      std::cout<<"MeasuredEcmsSvc, invalid RunFrom, RunFrom should be >=8093"<<std::endl;
  }
  m_sele = 0;
  log << MSG::INFO << "initialized successfully" << endreq;
  return StatusCode::SUCCESS;
}
 
// Finalize
StatusCode MeasuredEcmsSvc::finalize()
{
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "finalize begin here" << endreq;
 
  StatusCode status = Service::finalize();
  if (! status.isSuccess()) {
    log << MSG::ERROR << "can not finalize" << endreq;
    return status;
  }
 
  log << MSG::INFO << "finalized successfully" << endreq;
  return StatusCode::SUCCESS;
}
 
// Query interface
/*StatusCode MeasuredEcmsSvc::queryInterface(const InterfaceID &riid, void **ppvIF)
{
  if (IMeasuredEcmsSvc::interfaceID().versionMatch(riid)) *ppvIF = dynamic_cast<IMeasuredEcmsSvc*>(this);
  else return Service::queryInterface(riid, ppvIF);
 
  addRef();
 
  return StatusCode::SUCCESS;
}*/
 
// Handle
void MeasuredEcmsSvc::handle(const Incident &inc)
{
  MsgStream log(messageService(), name());
  log << MSG::DEBUG << "handle: " << inc.type() << endreq;
 
    SmartDataPtr<Event::EventHeader> eventHeader(m_eventSvc, "/Event/EventHeader");
    int runNo = eventHeader->runNumber();
    m_runNo = std::abs(runNo);
  if (inc.type() == "NewRun") {
    log << MSG::INFO << "RunNo is new, call the readMeasuredEcms again" << endreq;
        if(!m_readOneTime) {
           m_sele=0;
       readDBTable(runNo);
        } else {
           SmartDataPtr<Event::EventHeader> eventHeader(m_eventSvc,"/Event/EventHeader");
           int run = eventHeader->runNumber();
           if(run<0) run=-run;
           if(m_mapBeamE[run]>=0) {
              m_isRunNoValid = true;
              m_sele=m_mapBeamE[run];
           } else {
              std::cout<<"MeasuredEcmsSvc, could not get Ecm infor in handle new run"<<std::endl;
           }
        }
  }
}
 
// Return Ecms ( Ecms = beam_energy * 2 )
double MeasuredEcmsSvc::getEcms()
{
    switch (m_tableOption) {
        case 1:
            return (m_rowNo1 != 0) ? (double)m_dbRecordVector[m_sele]->GetDouble("Ecms") : 0.00;
        break;
 
        case 2:
            return (m_rowNo2 != 0) ? (double)m_dbRecordVector[m_sele]->GetDouble("beam_energy") * 2.00 : 0.00;
        break;
 
        default:
            if (m_rowNo1 != 0) return (double)m_dbRecordVector[m_sele]->GetDouble("Ecms");
                        else if (m_rowNo2 != 0) return (double)m_dbRecordVector[m_sele]->GetDouble("beam_energy") * 2.00;
                        else return 0.00;
        break;
    }
}
 
 
// Return Ecms depend on runNo only.
double MeasuredEcmsSvc::getEcms(int runNo)
{
    m_runNo = std::abs(runNo);
 
    readDBTable(runNo);
 
    switch (m_tableOption) {
    case 1:
      return (m_rowNo1 != 0) ? (double)m_dbRecordVector[m_sele]->GetDouble("Ecms") : 0.00;
    break;
 
    case 2:
      return (m_rowNo2 != 0) ? (double)m_dbRecordVector[m_sele]->GetDouble("beam_energy") * 2.00 : 0.00;
    break;
 
    default:
      if (m_rowNo1 != 0) return (double)m_dbRecordVector[m_sele]->GetDouble("Ecms");
            else if (m_rowNo2 != 0) return (double)m_dbRecordVector[m_sele]->GetDouble("beam_energy") * 2.00;
            else return 0.00;
    break;
  }
}
 
// read database table
void MeasuredEcmsSvc::readDBTable(int runNo)
{
    if (runNo == m_runflag) return;
    m_runflag = runNo;
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "begin read database MeasuredEcmsSvc" << endreq;
 
    m_dbRecordVector.clear();
 
    m_rowNo1 = 0;
    m_rowNo2 = 0;
 
    m_isRunNoValid = false;
    int runNum = std::abs(runNo);
 
  if (runNo < 0) log << MSG::INFO << "MeasuredEcmsSvc for MC events" << endreq;
  else log << MSG::INFO << "MeasuredEcmsSvc for DT events" << endreq;
 
    triggerDBTable(runNum);
 
  char stmt[400];
 
    char stmt1[400];
    char stmt2[400];
 
    switch(m_tableOption) {
        case 1:
            snprintf(stmt, 1024, "select sample, RunFrom, RunTo, Ecms, Ecms_err, Ave_Ecms, Ave_Ecms_err from MeasuredEcms2 where RunFrom <= %d and RunTo >= %d", runNum, runNum);
        break;
 
        case 2:
            snprintf(stmt, 1024, "select beam_energy, px, py, pz, beam_energy_err from RunParams where run_number = %d", runNum);
        break;
 
        default:
            snprintf(stmt1, 1024, "select sample, RunFrom, RunTo, Ecms, Ecms_err, Ave_Ecms, Ave_Ecms_err from MeasuredEcms2 where RunFrom <= %d and RunTo >= %d", runNum, runNum);
            snprintf(stmt2, 1024, "select beam_energy, px, py, pz, beam_energy_err from RunParams where run_number = %d", runNum);
        break;
    }
 
    if (m_tableOption == 1 || m_tableOption == 2) {
        int rowNo = m_dbSvc->query("offlinedb", stmt, m_dbRecordVector);
 
        if (rowNo == 0) { 
            log << MSG::ERROR << "RowNo can not be 0, failed to read DB for " << runNo << endreq; 
        }
        else {
            if (m_tableOption == 1) m_rowNo1 = 1;
            if (m_tableOption == 2) m_rowNo2 = 1;
            log << MSG::INFO << "initialize the DatabaseRecordVector OK for " << runNo << endreq;
            m_isRunNoValid = true;
        }
    }
    else {
        m_rowNo1 = m_dbSvc->query("offlinedb", stmt1, m_dbRecordVector);
        if (m_rowNo1 == 0) {
            m_dbRecordVector.clear();
            m_rowNo2 = m_dbSvc->query("offlinedb", stmt2, m_dbRecordVector);
        }
 
        if (m_rowNo1 == 0 && m_rowNo2 == 0) {
            log << MSG::ERROR << "RowNo can not be 0, failed to read DB for " << runNo << endreq;
        }
        else {
            log << MSG::INFO << "initialize the DatabaseRecordVector OK for " << runNo << endreq;
            m_isRunNoValid = true;
        }
    }
}
 
// read database table
void MeasuredEcmsSvc::readDBTable(int runFrom, int runTo)
{
   MsgStream log(msgSvc(), name());
   log << MSG::INFO << "begin read database MeasuredEcmsSvc from " << m_runFrom << " to " << m_runTo << endreq;
   m_dbRecordVector.clear();
 
   m_rowNo1 = 0;
   m_rowNo2 = 0;
   m_isRunNoValid = false;
   char stmt[400];
 
   if ((runFrom >= 23463 && runFrom <= 38140) || (runFrom >= 47543 && runFrom <= 51498)) {
      if ((runTo >= 23463 && runTo <= 38140) || (runTo >= 47543 && runTo <= 51498)) {
         log << MSG::INFO << "read table MeasuredEcms2 for " << runFrom <<":" << runTo << endreq;
     snprintf(stmt, 1024, "select sample, RunFrom, RunTo, Ecms, Ecms_err, Ave_Ecms, Ave_Ecms_err from MeasuredEcms2 where RunFrom >= %d and RunTo <= %d", runFrom, runTo);
         m_tableOption = 1;
      }
   } 
   else if ((runFrom >= 11414 && runFrom <= 23454) || (runFrom >= 43716 && runFrom <= 47066) || (runFrom >= 70522 && runFrom <= 73929) || (runFrom >= 74031 && runFrom <= 78536) ) {
      if ((runTo >= 11414 && runTo <= 23454) || (runTo >= 43716 && runTo <= 47066) || (runFrom >= 70522 && runFrom <= 73929) || (runFrom >= 74031 && runFrom <= 78536) ) {
         log << MSG::INFO << "read table RunParams for " << runFrom <<":" << runTo << endreq;
     snprintf(stmt, 1024, "select run_number, beam_energy, px, py, pz, beam_energy_err from RunParams where run_number >= %d and run_number <= %d", runFrom, runTo);
         m_tableOption = 2;
      }
   }
   else {
         m_tableOption = -1;
   }   
 
   if (m_tableOption == 1 || m_tableOption == 2) {
      int rowNo = m_dbSvc->query("offlinedb", stmt, m_dbRecordVector);
      if (rowNo == 0) { 
     log << MSG::ERROR << "RowNo can not be 0, failed to read DB for " << runFrom <<":" << runTo << endreq; 
         cout << "RowNo can not be 0, failed to read DB for " << runFrom <<":" << runTo << endl;
      } else {
     if (m_tableOption == 1) m_rowNo1 = 1;
     if (m_tableOption == 2) m_rowNo2 = 1;
     log << MSG::INFO << "initialize the DatabaseRecordVector OK for " << runFrom <<":" << runTo << endreq;
         cout << "MeasuredEcmsSvc: initialize the DatabaseRecordVector OK for " << runFrom <<":" << runTo << ", Nrecord = " << rowNo << "." << endl;
     m_isRunNoValid = true;
      }
      if (m_rowNo2==1) {
         for ( int i=0; i<rowNo; i++ ) {
            int runnumber = m_dbRecordVector[i]->GetInt("run_number");
            m_mapBeamE[runnumber] = i;
         }
      }
      if (m_rowNo1==1) {
         for ( int i=0; i<rowNo; i++ ) {
            int run0 = m_dbRecordVector[i]->GetInt("RunFrom");
            int run1 = m_dbRecordVector[i]->GetInt("RunTo");
            for ( int j = run0; j<=run1; j++) {
               m_mapBeamE[j] = i;
            }
         }
      }
   }
}
 
// triggerDBTable based on runNo 
int MeasuredEcmsSvc::triggerDBTable(int runNo)
{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "triggerDBTable based on runNo" << endl;
 
    int runNum = std::abs(runNo);
 
  if ((runNum >= 23463 && runNum <= 38140) || (runNum >= 47543 && runNum <= 51498)) {
        log << MSG::INFO << "read table MeasuredEcms2 for " << runNo << endreq;
        m_tableOption = 1;
    }
 
    else if ((runNum >= 11414 && runNum <= 23454) || (runNum >= 43716 && runNum <= 47066) || (runNum >= 70522 && runNum <= 73929) || (runNum >= 74031 && runNum <= 78536) ) {
        log << MSG::INFO << "read table RunParams for " << runNo << endreq;
        m_tableOption = 2;
    }
 
    else m_tableOption = -1;
 
    return m_tableOption;
}
 
 
// Return the string depend on the parameters
std::string MeasuredEcmsSvc::getRecord(int runNo, char *tab, char *col, char *min_col, char *max_col) 
{
    std::string strRecord;
    m_isRunNoValid = false;
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "MeasuredEcmsSvc begin read database " << tab << "-" << col << endreq;
 
  int runNum = std::abs(runNo);
 
  if (runNo < 0) log << MSG::INFO << "MeasuredEcmsSvc for MC events" << endreq;
  else log << MSG::INFO << "MeasuredEcmsSvc for DT events" << endreq;
 
  char stmt[500];
  snprintf(stmt, 1024, "select %s from %s where %s <= %d and %s >= %d", col, tab, min_col, runNum, max_col, runNum);
 
  DatabaseRecordVector res;
  int row_no = m_dbSvc->query("offlinedb", stmt, res);
 
  if(row_no == 0) {
        log << MSG::ERROR << "RowNo can not be 0 for " << tab << ", failed to read DB for " << runNo << endreq;
    }
  else {
    log << MSG::INFO << "MeasuredEcmsSvc first read the runNo, read the " << tab << " database " << runNo << endreq;
    strRecord = res[m_sele]->GetString(col);
        m_isRunNoValid = true;
  } 
 
    return strRecord;
}