VertexDbSvc.cxx

Go to the documentation of this file.

//     This service is used to read the vertex information from the database
//
//     an example to use this service is shown in test/test_read.cxx
//
//    the joboption for the example is shown in share/job-test.txt
//
//     the joboption for this service is shown in  share/jobOptions_VertexDbSvc.txt
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
 
#ifndef BEAN
#  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 "VertexDbSvc.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>
#else
#  include "VertexDbSvc.h"
#endif
 
using namespace std;
 
#ifndef BEAN
DECLARE_COMPONENT( VertexDbSvc )
VertexDbSvc::VertexDbSvc( 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( "BossVer", m_bossver = std::string( "default" ) );
  declareProperty( "VerPar", m_verpar = std::string( "default" ) );
  declareProperty( "BossRelease", m_bossRelease = std::string( "default" ) );
  declareProperty( "ReadOneTime", m_readOneTime = false );
  declareProperty( "RunFrom", m_runFrom = 8093 );
  declareProperty( "RunTo", m_runTo = 9025 );
  declareProperty( "RunIdList", m_runIdList );
}
 
VertexDbSvc::~VertexDbSvc() {}
 
/*StatusCode VertexDbSvc::queryInterface(const InterfaceID& riid, void** ppvInterface){
     if( IID_IVertexDbSvc.versionMatch(riid) ){
          *ppvInterface = static_cast<IVertexDbSvc*> (this);
     } else{
          return Service::queryInterface(riid, ppvInterface);
     }
     return StatusCode::SUCCESS;
}*/
 
StatusCode VertexDbSvc::initialize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "VertexDbSvc::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;
  }
  /*if(m_readOneTime){
    if(m_runFrom>=8093){
        getReadBunchInfo(m_runFrom, m_runTo);
    }
    else
      std::cout<<"VertexDbSvc, invalid RunFrom, RunFrom should be >=8093"<<std::endl;
  }*/
  for ( unsigned int i = 0; i < m_runIdList.size(); i++ )
  {
    m_runFrom = m_runIdList[i];
    i         = i + 2;
    m_runTo   = m_runIdList[i];
    if ( m_readOneTime )
    {
      if ( m_runFrom >= 8093 ) { getReadBunchInfo( m_runFrom, m_runTo ); }
      else std::cout << "VertexDbSvc, invalid RunFrom, RunFrom should be >=8093" << std::endl;
    }
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode VertexDbSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "VertexDbSvc::finalize()" << endmsg;
  //  if(m_connect_offline) delete m_connect_offline;
  return StatusCode::SUCCESS;
}
 
void VertexDbSvc::handle( const Incident& inc ) {
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "handle: " << inc.type() << endmsg;
 
  if ( inc.type() == "NewRun" )
  {
    log << MSG::DEBUG << "NewRun" << endmsg;
    if ( !m_readOneTime ) { getVertexTableInfo(); }
    else
    {
      SmartDataPtr<Event::EventHeader> eventHeader( m_eventSvc, "/Event/EventHeader" );
      int                              run = eventHeader->runNumber();
      // cout << endl << "New Run: " << run << " VertexDB vertex= ";
      if ( run < 0 ) run = -run;
      if ( ( m_mapPrimaryVertex[run] ).size() > 0 )
      {
        m_isRunNumberValid      = true;
        m_primaryVertex[0]      = ( m_mapPrimaryVertex[run] )[0];
        m_primaryVertex[1]      = ( m_mapPrimaryVertex[run] )[1];
        m_primaryVertex[2]      = ( m_mapPrimaryVertex[run] )[2];
        m_sigmaPrimaryVertex[0] = ( m_mapPrimaryVertex[run] )[3];
        m_sigmaPrimaryVertex[1] = ( m_mapPrimaryVertex[run] )[4];
        m_sigmaPrimaryVertex[2] = ( m_mapPrimaryVertex[run] )[5];
        // cout << m_primaryVertex[0] << "," << m_primaryVertex[1] << "," << m_primaryVertex[2]
        // << " sigma= " << m_sigmaPrimaryVertex[0] << "," << m_sigmaPrimaryVertex[1] << "," <<
        // m_sigmaPrimaryVertex[2] << endl;
      }
      else
      {
        std::cout << "VertexDbSvc, could not get vertex infor in handle new run" << std::endl;
      }
    }
  }
}
 
#else
// -------------------------- BEAN ------------------------------------
 
VertexDbSvc* VertexDbSvc::m_vdb = 0;
 
//-----------------------------------------------------------------------------
VertexDbSvc::VertexDbSvc()
//-----------------------------------------------------------------------------
{
  // use functions instead of "declareProperty"
  dbName = "offlinedb";
#  ifdef ROOTEVENTDATAVERSION
  m_bossver     = ROOTEVENTDATAVERSION;
  m_bossRelease = ROOTEVENTDATAVERSION;
#  else
  m_bossver     = "default";
  m_bossRelease = "default";
#  endif
  m_verpar = "default";
 
  m_dbsvc = DatabaseSvc::instance();
}
 
//-----------------------------------------------------------------------------
void VertexDbSvc::handle( int new_run )
//-----------------------------------------------------------------------------
{
  static int save_run = 0;
  if ( new_run == save_run ) return;
  getVertexTableInfo( new_run );
  save_run = new_run;
}
#endif
 
double* VertexDbSvc::PrimaryVertex() {
  if ( !m_isRunNumberValid )
  {
    cerr << "WARNING in VertexDbSvc: runNo is invalid!\n";
    memset( m_primaryVertex, 0, sizeof( m_primaryVertex ) );
  }
  return m_primaryVertex;
}
 
double* VertexDbSvc::SigmaPrimaryVertex() {
  if ( !m_isRunNumberValid )
  {
    cerr << "WARNING in VertexDbSvc: runNo is invalid!\n";
    memset( m_sigmaPrimaryVertex, 0, sizeof( m_sigmaPrimaryVertex ) );
  }
  return m_sigmaPrimaryVertex;
}
 
#ifndef BEAN
StatusCode VertexDbSvc::getVertexTableInfo() {
  MsgStream                        log( msgSvc(), name() );
  SmartDataPtr<Event::EventHeader> eventHeader( m_eventSvc, "/Event/EventHeader" );
  int                              run = eventHeader->runNumber();
#else
//-----------------------------------------------------------------------------
void VertexDbSvc::getVertexTableInfo( int run )
//-----------------------------------------------------------------------------
{
#endif
  m_isRunNumberValid = false;
  int save_run       = run;
 
  if ( run < 0 )
  {
#ifndef BEAN
    log << MSG::INFO << "This data is the MC sample with the Run Number: " << run << endmsg;
#else
    cout << "This data is the MC sample with the Run Number: " << run << endl;
#endif
    run = -run;
  }
  // #ifndef BEAN
  //   if(m_bossver=="default") m_bossver = getenv("BES_RELEASE");
  // #endif
 
  bool ret_vtx = getReadBunchInfo( run );
 
  if ( !ret_vtx )
  {
    cout << " VertexDbSvc:: can not found vertex information for run:" << run
         << ", boss version " << m_bossver << endl;
    exit( 1 );
  }
 
  /*  if( !ret_vtx && save_run<0 ) {
      bool ret = false;
      int real_run = run;
      for(int kk = 1; kk <= 10000; kk++) {
         real_run = run+kk;
         if( (ret = getReadBunchInfo(real_run)) ) break;
 
         if( run-kk > 0 ) {
           real_run = run-kk;
           if( (ret = getReadBunchInfo(real_run)) ) break;
         }
      }
      if( !ret ) {
  #ifndef BEAN
        log << MSG::ERROR << "Can not find vertex information for run:" <<run<< endmsg;
  #else
        cout << "Can not find vertex information for run:" << run << endl;
  #endif
        exit(1);
      }
  #ifndef BEAN
      log << MSG::INFO << "Use Bunch infor. of run " << real_run
          << " instead of run " << run << endmsg;
  #else
      cout << "Use Bunch infor. of run " << real_run
           << " instead of run " << run << endl;
  #endif
    }
  */
  m_isRunNumberValid = true;
#ifndef BEAN
  log << MSG::INFO << "Successfully fetch the vertex information for run: " << save_run
      << endmsg;
  return StatusCode::SUCCESS;
#else
  cout << "Successfully fetch the vertex information for run: " << save_run << endl;
#endif
}
 
//-----------------------------------------------------------------------------
bool VertexDbSvc::getReadBunchInfo( int run )
//-----------------------------------------------------------------------------
{
  if ( m_bossver == "default" )
  {
    if ( m_bossRelease == "default" )
    {
#ifndef BEAN
      MsgStream log( msgSvc(), name() );
      log << MSG::FATAL << "ERROR BossRelease must be set! Current value is " << m_bossRelease
          << "." << endmsg;
#else
      cout << "ERROR BossRelease must be set! Current value is " << m_bossRelease << "."
           << endl;
#endif
      exit( 1 );
    }
    else
    {
      char stmt1[400];
      sprintf( stmt1,
               "select SftVer, ParVer from CalVtxLumVer where BossRelease = '%s' and RunFrom "
               "<= %d and RunTo >= %d and DataType = 'LumVtx'",
               m_bossRelease.c_str(), run, run );
 
      DatabaseRecordVector records;
      int                  rowNo = m_dbsvc->query( "offlinedb", stmt1, records );
      if ( rowNo == 0 )
      {
#ifndef BEAN
        MsgStream log( msgSvc(), name() );
        log << MSG::ERROR << "ERROR: can not find records for run = " << run
            << " and BossRelease = " << m_bossRelease << endmsg;
#else
        cout << "ERROR: can not find records for run = " << run
             << " and BossRelease = " << m_bossRelease << endl;
#endif
        exit( 1 );
      }
      DatabaseRecord* recordst = records[0];
      m_bossver                = recordst->GetString( "SftVer" );
      m_verpar                 = recordst->GetString( "ParVer" );
      cout << "Using the SftVer and ParVer (" << m_bossver << ", " << m_verpar << ") for run "
           << run << ". " << endl;
    }
  }
 
  string       stmt = "select Vx, Vy, Vz, SigmaVx, SigmaVy, SigmaVz ";
  stringstream tmp;
  tmp << "from BeamPar where RunNo = " << run << " and SftVer=\'" << m_bossver << "\'";
  if ( m_verpar == "default" ) { tmp << " group by ParVer"; }
  else { tmp << " and ParVer = " << m_verpar; }
  stmt += tmp.str();
  // cerr << "query(" << dbName << ", " << stmt << ", res);" << endl;
 
  DatabaseRecordVector res;
  int                  row_no = m_dbsvc->query( dbName, stmt, res );
 
  if ( row_no > 0 )
  {
    DatabaseRecord& dbrec   = *res[row_no - 1];
    m_primaryVertex[0]      = dbrec.GetDouble( "Vx" );
    m_primaryVertex[1]      = dbrec.GetDouble( "Vy" );
    m_primaryVertex[2]      = dbrec.GetDouble( "Vz" );
    m_sigmaPrimaryVertex[0] = dbrec.GetDouble( "SigmaVx" );
    m_sigmaPrimaryVertex[1] = dbrec.GetDouble( "SigmaVy" );
    m_sigmaPrimaryVertex[2] = dbrec.GetDouble( "SigmaVz" );
    return true;
  }
 
  return false;
}
 
bool VertexDbSvc::getReadBunchInfo( int runFrom, int runTo )
//-----------------------------------------------------------------------------
{
  if ( m_bossver == "default" )
  {
    if ( m_bossRelease == "default" )
    {
#ifndef BEAN
      MsgStream log( msgSvc(), name() );
      log << MSG::FATAL << "ERROR BossRelease must be set! Current value is " << m_bossRelease
          << "." << endmsg;
#else
      cout << "ERROR BossRelease must be set! Current value is " << m_bossRelease << "."
           << endl;
#endif
      exit( 1 );
    }
    else
    {
      char stmt1[400];
      sprintf( stmt1,
               "select SftVer, ParVer from CalVtxLumVer where BossRelease = '%s' and RunFrom "
               "<= %d and RunTo >= %d and DataType = 'LumVtx'",
               m_bossRelease.c_str(), runFrom, runTo );
 
      DatabaseRecordVector records;
      int                  rowNo = m_dbsvc->query( "offlinedb", stmt1, records );
      if ( rowNo == 0 )
      {
#ifndef BEAN
        MsgStream log( msgSvc(), name() );
        log << MSG::ERROR << "ERROR: can not find records for run = " << runFrom
            << " and BossRelease = " << m_bossRelease << endmsg;
#else
        cout << "ERROR: can not find records for run = " << runFrom
             << " and BossRelease = " << m_bossRelease << endl;
#endif
        exit( 1 );
      }
      DatabaseRecord* recordst = records[0];
      m_bossver                = recordst->GetString( "SftVer" );
      m_verpar                 = recordst->GetString( "ParVer" );
      cout << "Using the SftVer and ParVer (" << m_bossver << ", " << m_verpar << ") for run "
           << runFrom << ". " << endl;
    }
  }
 
  string       stmt = "select RunNo, Vx, Vy, Vz, SigmaVx, SigmaVy, SigmaVz ";
  stringstream tmp;
  tmp << "from BeamPar where RunNo >= " << runFrom << " and RunNo <= " << runTo
      << " and SftVer=\'" << m_bossver << "\'";
  if ( m_verpar == "default" ) { tmp << " group by ParVer"; }
  else { tmp << " and ParVer = " << m_verpar; }
  stmt += tmp.str();
  // cerr << "query(" << dbName << ", " << stmt << ", res);" << endl;
 
  DatabaseRecordVector res;
  int                  row_no = m_dbsvc->query( dbName, stmt, res );
 
  std::cout << "VertexDbSvc get all vertex info, row_no: " << row_no << std::endl;
  if ( row_no > 0 )
  {
    for ( int i = 0; i < row_no; i++ )
    {
      DatabaseRecord&     dbrec = *res[i];
      int                 run   = dbrec.GetInt( "RunNo" );
      std::vector<double> vertex;
      vertex.push_back( dbrec.GetDouble( "Vx" ) );
      vertex.push_back( dbrec.GetDouble( "Vy" ) );
      vertex.push_back( dbrec.GetDouble( "Vz" ) );
      vertex.push_back( dbrec.GetDouble( "SigmaVx" ) );
      vertex.push_back( dbrec.GetDouble( "SigmaVy" ) );
      vertex.push_back( dbrec.GetDouble( "SigmaVz" ) );
      m_mapPrimaryVertex[run] = vertex;
    }
    return true;
  }
 
  return false;
}