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 <iostream>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
 
#include "EmcShEnCalibSvc/EmcShEnCalibSvc.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/PropertyMgr.h"
 
 
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/IIncidentListener.h"
 
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Bootstrap.h"
#include "EventModel/EventModel.h"
#include "EventModel/Event.h"
#include "EventModel/EventHeader.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(messageService(), name());
  log << MSG::INFO << "EmcShEnCalibSvc::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;
  }
  
  return StatusCode::SUCCESS;
}
 
StatusCode EmcShEnCalibSvc::finalize(){
  MsgStream log(messageService(), name());
  log << MSG::INFO << "EmcShEnCalibSvc::finalize()" << endreq;
  //  if(m_connect_offline) delete m_connect_offline;
  return StatusCode::SUCCESS;
}
 
void EmcShEnCalibSvc::handle(const Incident& inc){
  MsgStream log( messageService(), name() );
  log << MSG::DEBUG << "handle: " << inc.type() << endreq;
 
  if ( inc.type() == "NewRun" ){
    log << MSG::DEBUG << "NewRun" << endreq;
 
    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<< endreq;
    //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" << endreq;
      } 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 " << endreq;
    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(messageService(), 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;
}