EmcCalibConstSvc.cxx

Go to the documentation of this file.

#include "EmcCalibConstSvc/EmcCalibConstSvc.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/Bootstrap.h"
 
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/DataSvc.h"
#include "GaudiKernel/PropertyMgr.h"
 
#include "EmcGeneralClass/EmcStructure.h"
#include "CalibData/CalibModel.h"
#include "CalibData/Emc/EmcCalibData.h"
 
#include <vector>
#include <math.h>
#include <fstream>
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/IIncidentListener.h"
 
 
#include "EventModel/EventModel.h"
#include "EventModel/Event.h"
#include "EventModel/EventHeader.h"
 
 
 
EmcCalibConstSvc::EmcCalibConstSvc( const std::string& name, ISvcLocator* svcloc) :
  Service (name, svcloc) {
 
  m_EmaxVersion1=false;
  m_EmaxVersion2=false;
  m_DeadEcutVersion2020=false;
 
  for(int i=0;i<6240;i++){
    m_CrystalEmaxData[i]=0;
    m_CrystalEmaxData_1[i]=0;
    m_CrystalEmaxData_2[i]=0;
    m_CrystalDeadEcut[i]=-1;
    m_CrystalDeadEcut_2020[i]=-1;
  }
 
  int ixtal;
  double emaxData;
  int Nixt=0;
 
  ///for version 1/////////
  string paraPath = getenv("EMCCALIBCONSTSVCROOT");
  paraPath += "/share/emax_data.dat";  // version=1
  ifstream in;
  in.open(paraPath.c_str());
  assert(in);
 
  while (in.peek() != EOF) 
    { 
      
      in >> ixtal>>emaxData;
 
      m_CrystalEmaxData_1[ixtal]=emaxData;
      Nixt++; 
      // cout<<"readFile==============="<<emaxData<<endl;
    }
 
  in.close();
 
 
  ////version 2///////////
  string paraPath2 = getenv("EMCCALIBCONSTSVCROOT");
  paraPath2 += "/share/emax_data_2.dat";  // version=2
 
  ifstream in2;
  in2.open(paraPath2.c_str());
  assert(in2);
 
  Nixt=0;
  while (in2.peek() != EOF) 
    { 
      
      in2 >> ixtal>>emaxData;
 
      m_CrystalEmaxData_2[ixtal]=emaxData;
     
      Nixt++; 
      // cout<<"readFile2==============="<<emaxData<<endl;
    }
 
  in2.close();
 
 ////read dead channel energy threshould Ecut///////////
  string paraPath3 = getenv("EMCCALIBCONSTSVCROOT");
  paraPath3 += "/share/DeadThresholdEcut_2020.conf";  
 
  ifstream in3;
  in3.open(paraPath3.c_str());
  assert(in3);
 
  Nixt=0;
  double satuEn,Ecut;
  double DeltaEcut=0.0; 
  
  while (in3.peek() != EOF) 
    { 
      
      in3 >> ixtal>>satuEn>>Ecut;
      if ((Ecut-satuEn)>DeltaEcut) {
    m_CrystalDeadEcut_2020[ixtal]=Ecut-DeltaEcut;
      } else {
    m_CrystalDeadEcut_2020[ixtal]=Ecut;
      }
      Nixt++; 
      
    }
 
  in3.close();
 
}
 
EmcCalibConstSvc::~EmcCalibConstSvc(){
 
}
 
StatusCode EmcCalibConstSvc::queryInterface(const InterfaceID& riid, void** ppvInterface){
     if( IID_IEmcCalibConstSvc.versionMatch(riid) ){
      *ppvInterface = static_cast<IEmcCalibConstSvc*> (this);
     } else{
      return Service::queryInterface(riid, ppvInterface);
     }
     return StatusCode::SUCCESS;
}
 
StatusCode EmcCalibConstSvc::initialize(){
  MsgStream log(messageService(), name());
  log << MSG::INFO << "EmcCalibConstSvc::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("EventDataSvc", m_eventSvc, true);
  if (sc .isFailure() ) {
    log << MSG::ERROR << "Unable to find EventDataSvc " << endreq;
    return sc;
  }
 
  sc = service("CalibDataSvc", m_calDataSvc, true);
  if( sc == StatusCode::SUCCESS ){
    log << MSG::INFO << "Retrieve IDataProviderSvc" << endreq;
  }else{
    log << MSG::FATAL << "can not get IDataProviderSvc" << endreq;
  }
 
  //     sc = service("EmcRecGeoSvc", m_emcGeomSvc);
  //     if( sc != StatusCode::SUCCESS ){
  //      log << MSG::ERROR << "can not use EmcRecGeoSvc" << endreq;
  // }
  
  m_theEmcStruc= new EmcStructure() ; 
  m_theEmcStruc->setEmcStruc();
 
  //Dump();
  //cout<<"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& EmcCalibConstSvc initialize"<<endl;
  return StatusCode::SUCCESS;
}
 
StatusCode EmcCalibConstSvc::finalize(){
 
     delete m_theEmcStruc;
 
     MsgStream log(messageService(), name());
     log << MSG::INFO << "EmcCalibConstSvc::finalize()" << endreq;
     return StatusCode::SUCCESS;
 
}
 
void EmcCalibConstSvc::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<<"&&&&&&&&&&&&&&:&&&&&&&&&&&&&&&&&&&& EmcCalibConstSvc handle,run="<<run<<endl;
      if (run<0) run = -run;
    
 
      log << MSG::DEBUG << "handle: " <<"Run in handle is: "<<run<< endreq;
      //run <63075: EmaxVersion=1; run>=63075: EmaxVersion=2;
      cout<< "handle: " <<"Run in handle is: "<<run<<endl;
      if (run<63075&& !m_EmaxVersion1) {
        setCrystalEmaxData(m_CrystalEmaxData_1); 
        m_EmaxVersion1=true;
        m_EmaxVersion2=false;
        
        
        cout<< "handle: " <<"EmaxVersion="<<"111111111111111"<<endl;
      }
      
      
      if (run>=63075&& !m_EmaxVersion2) {
        setCrystalEmaxData(m_CrystalEmaxData_2); 
        m_EmaxVersion2=true;
        m_EmaxVersion1=false;
        cout<< "handle: " <<"EmaxVersion="<<"222222222222"<<endl;
      }
 
      if (run>=63075&&run<=65092&&!m_DeadEcutVersion2020){
        setCrystalDeadEcut(m_CrystalDeadEcut_2020);
        m_DeadEcutVersion2020=true;
        cout<< "handle: " <<"DeadEcutVersion="<<"2020"<<endl;
      }
 
      //if(!getCrystalEmaxDataFileInfo()){
      //    log << MSG::ERROR << "can not find the crystal EmaxData file" << endreq;
      //}
      
      // Dump();
    } 
    
        
}
 
 
 
double EmcCalibConstSvc::getDigiCalibConst(int No)   const
 {
     double digiCalibConst = 0.0;
     MsgStream log(messageService(), name());
     
     std::string fullPath = "/Calib/EmcCal";
     SmartDataPtr<CalibData::EmcCalibData> calConst(m_calDataSvc, fullPath);
     if( ! calConst ){
      log << MSG::ERROR << "can not access to EmcDigi CalibData via SmartPtr" 
          << endreq;
     }else {
         digiCalibConst = calConst->getDigiCalibConst(No);
     }
     
     return digiCalibConst;
}
 
int EmcCalibConstSvc::getIxtalNumber(int No)   const
 {
     int IxtalNumber = 999999;
     MsgStream log(messageService(), name());
     
     std::string fullPath = "/Calib/EmcCal";
     SmartDataPtr<CalibData::EmcCalibData> calConst(m_calDataSvc, fullPath);
     if( ! calConst ){
      log << MSG::ERROR << "can not access to EmcDigi CalibData via SmartPtr" 
          << endreq;
     }else {
         IxtalNumber = calConst->getIxtalNumber(No);
     }
     
     return IxtalNumber;
}
 
int EmcCalibConstSvc::getDigiCalibConstNo( ) const
 {
     int digiCalibConstNo = 0;
     MsgStream log(messageService(), name());
     
     std::string fullPath = "/Calib/EmcCal";
     SmartDataPtr<CalibData::EmcCalibData> calConst(m_calDataSvc, fullPath);
     if( ! calConst ){
      log << MSG::ERROR << "can not access to EmcDigiNo CalibData via SmartPtr" 
          << endreq;
     }else {
        digiCalibConstNo = calConst->getDigiCalibConstNo();
     }
     
     return digiCalibConstNo;
}
 
int EmcCalibConstSvc::getIxtalNumberNo( ) const
 {
     int IxtalNumberNo = 0;
     MsgStream log(messageService(), name());
     
     std::string fullPath = "/Calib/EmcCal";
     SmartDataPtr<CalibData::EmcCalibData> calConst(m_calDataSvc, fullPath);
     if( ! calConst ){
      log << MSG::ERROR << "can not access to EmcDigiNo CalibData via SmartPtr" 
          << endreq;
     }else {
        IxtalNumberNo = calConst->getIxtalNumberNo();
     }
     
     return IxtalNumberNo;
}
 
 
 
int EmcCalibConstSvc::getIndex( unsigned int PartId, 
                unsigned int ThetaIndex, 
                unsigned int PhiIndex)  const
{
  return m_theEmcStruc->getGeomIndex(PartId, ThetaIndex, PhiIndex);
}
 
 
unsigned int EmcCalibConstSvc::getPartID(int Index) const
{
  return m_theEmcStruc->getPartId(Index);
}
 
unsigned int EmcCalibConstSvc::getThetaIndex( int Index)  const 
{
  return m_theEmcStruc->getTheta(Index);
}
 
unsigned int EmcCalibConstSvc::getPhiIndex( int Index)  const  
{
  return m_theEmcStruc->getPhi(Index);
}
 
 
 
double EmcCalibConstSvc::getCrystalEmaxData( int Index)  const
{
  return m_CrystalEmaxData[Index];
}
 
double EmcCalibConstSvc::getCrystalDeadEcut( int Index)  const
{
  return m_CrystalDeadEcut[Index];
}
 
 
void   EmcCalibConstSvc::Dump()
{
  /*
  for(int iNo=0;iNo<6;iNo++){
    cout<<"getDigiCalibConst "<<getDigiCalibConst(iNo)<<endl;
  }
 
  cout<<"getDigiCalibConstNo "<<getDigiCalibConstNo()<<endl;
 
  
   cout<<"ind"<<"  "<<"getThetaIndex(ind)"<<"  "
       <<"getPhiIndex(ind)"<<"getPartID"<<endl;
 
  for(int ind=0; ind<6240;ind++){
 
    cout<<ind<<"  "<<getThetaIndex(ind)<<"  "
    <<getPhiIndex(ind)<<"  "<<getPartID(ind)<<endl;  
  
  }
 
  cout<<"getIndex(0,5,95)="<<getIndex(0,5,95)<<endl;
  cout<<"getIndex(1,43,119)="<<getIndex(1,43,119)<<endl;
  cout<<"getIndex(2,5,95)="<<getIndex(2,5,95)<<endl;
  cout<<"getIndex(0,5,96)="<<getIndex(0,5,96)<<endl;
  cout<<"getIndex(1,43,120)="<<getIndex(1,43,120)<<endl;
  cout<<"getIndex(2,5,96)="<<getIndex(2,5,96)<<endl;
  */
  for(int i=0;i<6240;i++){
    cout<<i<<"\t"<<getCrystalEmaxData(i) <<endl;
  }
  
 
}