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.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" << endmsg;
}
 
// Initialize
StatusCode MeasuredEcmsSvc::initialize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "initialize begin here" << endmsg;
 
  StatusCode status = Service::initialize();
  if ( !status.isSuccess() )
  {
    log << MSG::ERROR << "can not initialize" << endmsg;
    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" << endmsg;
    return status;
  }
 
  status = serviceLocator()->service( "EventDataSvc", m_eventSvc, true );
  if ( !status.isSuccess() )
  {
    log << MSG::ERROR << "unable to find EventDataSvc " << endmsg;
    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" << endmsg;
  return StatusCode::SUCCESS;
}
 
// Finalize
StatusCode MeasuredEcmsSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "finalize begin here" << endmsg;
 
  StatusCode status = Service::finalize();
  if ( !status.isSuccess() )
  {
    log << MSG::ERROR << "can not finalize" << endmsg;
    return status;
  }
 
  log << MSG::INFO << "finalized successfully" << endmsg;
  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( msgSvc(), name() );
  log << MSG::DEBUG << "handle: " << inc.type() << endmsg;
 
  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" << endmsg;
    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" << endmsg;
 
  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" << endmsg;
  else log << MSG::INFO << "MeasuredEcmsSvc for DT events" << endmsg;
 
  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 << endmsg; }
    else
    {
      if ( m_tableOption == 1 ) m_rowNo1 = 1;
      if ( m_tableOption == 2 ) m_rowNo2 = 1;
      log << MSG::INFO << "initialize the DatabaseRecordVector OK for " << runNo << endmsg;
      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 << endmsg; }
    else
    {
      log << MSG::INFO << "initialize the DatabaseRecordVector OK for " << runNo << endmsg;
      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 << endmsg;
  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 << endmsg;
      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 ) ||
            ( runFrom >= 78615 && runFrom <= 81631 ) )
  {
    if ( ( runTo >= 11414 && runTo <= 23454 ) || ( runTo >= 43716 && runTo <= 47066 ) ||
         ( runFrom >= 70522 && runFrom <= 73929 ) ||
         ( runFrom >= 74031 && runFrom <= 78536 ) || ( runFrom >= 78615 && runFrom <= 81631 ) )
    {
      log << MSG::INFO << "read table RunParams for " << runFrom << ":" << runTo << endmsg;
      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 << endmsg;
      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 << endmsg;
      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 << endmsg;
    m_tableOption = 1;
  }
 
  else if ( ( runNum >= 11414 && runNum <= 23454 ) || ( runNum >= 43716 && runNum <= 47066 ) ||
            ( runNum >= 70522 && runNum <= 73929 ) || ( runNum >= 74031 && runNum <= 78536 ) ||
            ( runNum >= 78615 && runNum <= 81631 ) )
  {
    log << MSG::INFO << "read table RunParams for " << runNo << endmsg;
    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 << endmsg;
 
  int runNum = std::abs( runNo );
 
  if ( runNo < 0 ) log << MSG::INFO << "MeasuredEcmsSvc for MC events" << endmsg;
  else log << MSG::INFO << "MeasuredEcmsSvc for DT events" << endmsg;
 
  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 << endmsg;
  }
  else
  {
    log << MSG::INFO << "MeasuredEcmsSvc first read the runNo, read the " << tab
        << " database " << runNo << endmsg;
    strRecord      = res[m_sele]->GetString( col );
    m_isRunNoValid = true;
  }
 
  return strRecord;
}