EmcShEnCalibSvc.cxx

Go to the documentation of this file.

//     This service is used to read the EmcShEnCalibSvc  information from the database
//
//     the joboption for this service is shown in  share/jobOptions_EmcShEnCalibSvc.txt
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/PropertyMgr.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/StatusCode.h"
 
#include "EventModel/Event.h"
#include "EventModel/EventHeader.h"
#include "EventModel/EventModel.h"
 
#include "EmcShEnCalibSvc.h"
 
#include <TMath.h>
 
using namespace std;
 
DECLARE_COMPONENT( EmcShEnCalibSvc )
 
EmcShEnCalibSvc::EmcShEnCalibSvc( const string& name, ISvcLocator* svcloc )
    : base_class( name, svcloc ) {
  // declare properties
  declareProperty( "Host", host = std::string( "bes3db2.ihep.ac.cn" ) );
  declareProperty( "DbName", dbName = std::string( "offlinedb" ) );
  declareProperty( "UserName", userName = std::string( "guest" ) );
  declareProperty( "Password", password = std::string( "guestpass" ) );
  declareProperty( "BossRelease", m_bossRelease = std::string( "default" ) );
  declareProperty( "EmcShEnCalibPar", m_calPar = "default" );
  declareProperty( "EmcShEnCalibBossVer", m_bossVer = "default" );
  m_ReadPar = false;
  m_RunFrom = 0;
  m_RunTo   = 0;
}
 
EmcShEnCalibSvc::~EmcShEnCalibSvc() {}
 
/*StatusCode EmcShEnCalibSvc::queryInterface(const InterfaceID& riid, void** ppvInterface){
  if( IID_IEmcShEnCalibSvc.versionMatch(riid) ){
    *ppvInterface = static_cast<IEmcShEnCalibSvc*> (this);
  } else{
    return Service::queryInterface(riid, ppvInterface);
  }
  return StatusCode::SUCCESS;
}*/
 
StatusCode EmcShEnCalibSvc::initialize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "EmcShEnCalibSvc::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( "DatabaseSvc", m_dbsvc, true );
  if ( sc.isFailure() )
  {
    log << MSG::ERROR << "Unable to find DatabaseSvc " << endmsg;
    return sc;
  }
 
  sc = serviceLocator()->service( "EventDataSvc", m_eventSvc, true );
  if ( sc.isFailure() )
  {
    log << MSG::ERROR << "Unable to find EventDataSvc " << endmsg;
    return sc;
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode EmcShEnCalibSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "EmcShEnCalibSvc::finalize()" << endmsg;
  //  if(m_connect_offline) delete m_connect_offline;
  return StatusCode::SUCCESS;
}
 
void EmcShEnCalibSvc::handle( const Incident& inc ) {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "handle: " << inc.type() << endmsg;
 
  if ( inc.type() == "NewRun" )
  {
    log << MSG::DEBUG << "NewRun" << endmsg;
 
    SmartDataPtr<Event::EventHeader> eventHeader( m_eventSvc, "/Event/EventHeader" );
    int                              run = eventHeader->runNumber();
    // cout<<"&&&&&&&&&&&&&&:&&&&&&&&&&&&&&&&&&&& EmcShEnCalibSvc handle,run="<<run<<endl;
    if ( run < 0 ) run = -run;
    log << MSG::DEBUG << "handle: "
        << "Run in handle is: " << run << endmsg;
    // cout<<"-------------in EmcShEnCalibSvc 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 ( !getEmcShEnCalibSvcInfo() )
      { log << MSG::ERROR << "can not initilize Shower energy Calib Constants" << endmsg; }
      else
      {
        m_ReadPar = true;
        // std::cout << "in handle of EmcShEnCalibSvc  getPi0CalibFile()= " <<
        // getPi0CalibFile()<<std::endl; std::cout << "getSingleGammaCalibFile()= " <<
        // getSingleGammaCalibFile() << std::endl;
      }
    }
  }
}
 
// select sftver and parver frm table CalVtxLum
StatusCode EmcShEnCalibSvc::getSftParVer( std::string& SftVer, std::string& CalParVer,
                                          int& runfrm, int& runto, int RunNo,
                                          std::string BossRelease, std::string DataType ) {
  MsgStream            log( msgSvc(), "EmcShEnCalibSvc" );
  char                 stmt[300];
  int                  run_No = RunNo;
  MYSQL_RES*           res_set;
  IDatabaseSvc*        m_dbsvc;
  DatabaseRecordVector res;
  StatusCode           sc = serviceLocator()->service( "DatabaseSvc", m_dbsvc, true );
  if ( sc.isFailure() )
  {
    log << MSG::ERROR << " Unable to find DatabaseSvc " << endmsg;
    return sc;
  }
 
  const char* bossRelease = BossRelease.c_str();
  const char* dataType    = DataType.c_str();
 
  sprintf( stmt,
           "select RunFrom,RunTo,SftVer,ParVer from CalVtxLumVer where BossRelease = '%s' and "
           "RunFrom <= %d and RunTo "
           ">= %d and DataType='%s' ",
           bossRelease, run_No, run_No, dataType );
  // cout<<"stmt="<<stmt<<endl;
 
  int row_no = m_dbsvc->query( "offlinedb", stmt, res );
  // cout<<"raw_no="<<row_no<<endl;
  if ( row_no < 1 )
  {
    std::cout << "ERROR:error searching with:" << stmt << std::endl;
    exit( 1 );
  }
  if ( row_no == 1 )
  {
    DatabaseRecord* records1 = res[0];
    runfrm                   = records1->GetInt( "RunFrom" );
    runto                    = records1->GetInt( "RunTo" );
    // cout<<dataType<<" runfrm,runto in getSftParVer is:"<<runfrm<<"::::"<<runto<<endl;
 
    SftVer    = records1->GetString( "SftVer" );
    CalParVer = records1->GetString( "ParVer" );
    // cout<<"stmt="<<stmt<<"\t"<<SftVer<<"\t"<<CalParVer<<endl;
  }
  if ( row_no > 1 )
  {
    cout << "ERROR: " << dataType << " set overlapped run number in the table CalVtxLumVer"
         << endl;
    exit( 1 );
  }
  return StatusCode::SUCCESS;
}
 
bool EmcShEnCalibSvc::getEmcShEnCalibSvcInfo() {
  MsgStream                        log( msgSvc(), name() );
  SmartDataPtr<Event::EventHeader> eventHeader( m_eventSvc, "/Event/EventHeader" );
  int                              run = eventHeader->runNumber();
  // cout<<"Run in getEmcShEnCalibSvcInfo() 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         runfrm1;
  int         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 EmcShEnCalibSvc information for run: " << run << endl;
    //cout<<"////////// read parameters from EmcShEnCalibConst database/////////////"<<endl;
    */
    return true;
  }
  else if ( row_no <= 0 )
  {
    cout << " EmcShEnCalibSvc:: can not found EmcShEnCalibSvc information of run:" << run
         << ", boss version " << m_bossRelease << endl;
    exit( 1 );
    return false;
  }
  return true;
}