MrpcRec.cxx

Go to the documentation of this file.

//  Package: MrpcRec
//  BESIII Tof Reconstruction Algorithm. 
//  Created by Sun Shengsen (EPC IHEP)
//
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/AlgFactory.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/SmartDataLocator.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/PropertyMgr.h"
#include "EventModel/EventHeader.h"
#include "EventModel/EventModel.h"
#include "ReconEvent/ReconEvent.h"
#include "McTruth/McParticle.h"
#include "McTruth/TofMcHit.h"
#include "McTruth/McParticle.h"
#include "EvTimeEvent/RecEsTime.h"
#include "ExtEvent/RecExtTrack.h"
#include "DstEvent/TofHitStatus.h"
#include "TofRecEvent/RecTofTrack.h"
#include "TofRecEvent/RecBTofCalHit.h"
#include "TofRecEvent/RecETofCalHit.h"
#include "TofGeomSvc/ITofGeomSvc.h"
#include "TofCaliSvc/ITofCaliSvc.h"
#include "RawDataProviderSvc/IRawDataProviderSvc.h"
#include "RawDataProviderSvc/TofData.h"
#include "MrpcRec/MrpcRec.h"
#include "MrpcRec/MrpcTrack.h"
#include "MrpcRec/MrpcCount.h"
#include "MrpcRec/MrpcRecTDS.h"
#include <iostream>
 
#include "MdcRecEvent/RecMdcTrack.h"
#include "EmcRecEventModel/RecEmcShower.h"
 
using namespace std;
using namespace Event;
 
/////////////////////////////////////////////////////////////////////////////
 
ITofGeomSvc* tofGeomSvc;
ITofCaliSvc* tofCaliSvc;
// ITofQCorrSvc* tofQCorrSvc;
// ITofQElecSvc* tofQElecSvc;
IRawDataProviderSvc* tofDigiSvc;
 
MrpcRec::MrpcRec(const std::string& name, ISvcLocator* pSvcLocator) :
  Algorithm(name, pSvcLocator)
{   
  declareProperty( "AcceleratorStatus", m_acceleratorStatus );
  declareProperty( "MagneticField",     m_magneticField     );
  declareProperty( "FirstIteration",    m_firstIteration    );
  declareProperty( "PrintOutInfo",      m_printOutInfo      );
  declareProperty( "neighborhood",      m_neighborhood=6    );//For the time being: 6 is the standardvalue -> It yield the highest reconstruction efficiency! 
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 
StatusCode MrpcRec::initialize(){
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "MrpcRec in initialize()" << endreq;   
 
  //Get TOF Geomertry Service
  StatusCode scg = service("TofGeomSvc", tofGeomSvc);
  if (scg==  StatusCode::SUCCESS) {
    log << MSG::INFO << "MrpcRec Get Geometry Service Sucessfully!" << endreq;
  }else {
    log << MSG::ERROR << "MrpcRec Get Geometry Service Failed !" << endreq;
    return StatusCode::FAILURE;
  }
 
  //Get TOF Calibtration Service
  StatusCode scc = service("TofCaliSvc", tofCaliSvc);
  if (scc ==  StatusCode::SUCCESS) { 
    log << MSG::INFO << "MrpcRec Get Calibration Service Sucessfully!" << endreq;
  } else {
    log << MSG::ERROR << "MrpcRec Get Calibration Service Failed !" << endreq;
    return StatusCode::FAILURE;
  }
 
  //Get TOF Raw Data Provider Service
  StatusCode scd = service("RawDataProviderSvc", tofDigiSvc);
  if (scd ==  StatusCode::SUCCESS) { 
    log << MSG::INFO << "MrpcRec Get Tof Raw Data Service Sucessfully!" << endreq;
  } else {
    log << MSG::ERROR << "MrpcRec Get Tof Raw Data Service Failed !" << endreq;
    return StatusCode::FAILURE;
  }
 
 
  if( m_printOutInfo ) { m_printOut = new MrpcCount; }
 
  return StatusCode::SUCCESS;
}
 
StatusCode MrpcRec::beginRun(){
  MsgStream log(msgSvc(), name());
  log << MSG::INFO <<"MrpcRec begin_run!"<< endreq;
  return StatusCode::SUCCESS;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 
StatusCode MrpcRec::execute() {
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "MrpcRec in execute()!" << endreq;
 
  SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
  if( !eventHeader ) {
    log << MSG::FATAL << "MrpcRec could not find Event Header!" << endreq;
    return StatusCode::FAILURE;
  }
  int run = eventHeader->runNumber();
  int event = eventHeader->eventNumber();
  if( ( event % 1000 == 0 ) && m_printOutInfo ) {
    std::cout << "run:" << run << "  event: " << event << std::endl;
  }
  log << MSG::INFO << "run= " << run << "  event= " << event << endreq;
 
  MrpcRecTDS tds;
  tds.RegisterNullRecTofTrackCol();
 
  // Magnetic Field: Colliding data and Cosmic Ray
  if( m_acceleratorStatus == "Colliding" ) {
    // Retrieve Event Start Time
    SmartDataPtr<RecEsTimeCol> estimeCol(eventSvc(),"/Event/Recon/RecEsTimeCol");
    if( !estimeCol || ( estimeCol->size() == 0 ) ) { 
      log << MSG::WARNING << "MrpcRec Could not find RecEsTimeCol!   Run = " << run << " Event = " << event << endreq;
      return StatusCode::SUCCESS;
    } 
    RecEsTimeCol::iterator iter_ESTime=estimeCol->begin();
    double t0  = (*iter_ESTime)->getTest();
    int t0Stat = (*iter_ESTime)->getStat();
    log << MSG::INFO << "t0= " << t0 << "  t0Stat= " << t0Stat << endreq;
 
 
 
    // Kalman Filter Track
    SmartDataPtr<RecMdcKalTrackCol> mdcKalTrackCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
    if( !mdcKalTrackCol ) {
      log << MSG::WARNING << "No MdcKalTrackCol in TDS!   Run = " << run << "  Event = " << event << endreq;
      return StatusCode::SUCCESS;
    }
 
 
 
    // Tof Get Extrapolated Track
    SmartDataPtr<RecExtTrackCol> extTrackCol(eventSvc(),"/Event/Recon/RecExtTrackCol");
    if( !extTrackCol ) {
      log << MSG::WARNING << "No ExtTrackCol in TDS!   Run = " << run << "  Event = " << event << endreq;
      return StatusCode::SUCCESS;
    }
    else {
      if( m_printOutInfo ) { m_printOut->setExtTrackNum( extTrackCol->size() ); }
    }
 
 
 
    TofTrackVec* tofTrackVec = new TofTrackVec;
    RecExtTrackCol::iterator iter_track = extTrackCol->begin();
    for( ; iter_track < extTrackCol->end(); iter_track++ ) {
      RecMdcKalTrackCol::iterator iter_kal = mdcKalTrackCol->begin();
      for( ; iter_kal != mdcKalTrackCol->end(); iter_kal++ ) {
    if( (*iter_kal)->trackId() == (*iter_track)->trackId() ) break;
      }
      int kal[5] = {-1};
      if( iter_kal != mdcKalTrackCol->end() ) {
    for( unsigned int i=0; i<5; i++ ) {
      kal[i] = (*iter_kal)->getStat( 1, i );
    }
      }
      MrpcTrack* tof = new MrpcTrack;
      tof->setExtTrack( (*iter_track), kal, t0, t0Stat );
 
      if( tofTrackVec->size()>0 ) {
    std::vector<MrpcTrack*>::iterator iterExt = tofTrackVec->begin();
    for( ; iterExt < tofTrackVec->end(); iterExt++ ) {
      if( (*iterExt)->isNoHit() ) continue;
      tof->getMultiHit( *iterExt );
    }
      }
 
      tofTrackVec->push_back( tof );
    }
 
    if( m_printOutInfo ) {
      m_printOut->setTrack1Col( tofTrackVec );
    }
 
    // Retrieve Tof Digi Data
    TofDataMap tofDataMap = tofDigiSvc->tofDataMapTof( t0 );
    if( tofDataMap.empty() ) {
      log << MSG::WARNING << "No Tof Data Map in RawDataProviderSvc!   Run=" << run << " Event=" << event << endreq;
    }
 
 
    std::vector<MrpcTrack*>::iterator iter = tofTrackVec->begin();
    for( ; iter < tofTrackVec->end(); iter++ ) {
      if( (*iter)->isNoHit() ) continue;
      (*iter)->setTofData( tofDataMap,m_neighborhood );
      if( m_printOutInfo ) { m_printOut->setTrack2( (*iter) ); }
      if( (*iter)->isNoHit() ) continue;
      (*iter)->match(tofTrackVec );
      if( m_printOutInfo ) { m_printOut->setTrack3( (*iter) ); }
    }
 
    iter = tofTrackVec->begin();
    for( ; iter < tofTrackVec->end(); iter++ ) 
      {
    (*iter)->setCalibration();
      }
 
    tds.RegisterTDS( eventHeader->runNumber(), eventHeader->eventNumber(), tofTrackVec );
 
    clearTofTrackVec( tofTrackVec );
 
// Check RecTofTrackCol Registered
    SmartDataPtr<RecTofTrackCol> tofTrackCol(eventSvc(),"/Event/Recon/RecTofTrackCol");  
    if (!tofTrackCol) { 
      log << MSG::FATAL << "MrpcRec could not find RecTofTrackCol!" << endreq;
      return StatusCode::FAILURE;
    }
 
  }
  else {
    log << MSG::FATAL << "In MrpcRec: AcceleratorStatus is NOT correct! m_acceleratorStatus = " << m_acceleratorStatus << endreq;
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
 
}
 
//   * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 
StatusCode MrpcRec::finalize() {
  if( m_printOutInfo ) {
    m_printOut->final();
    delete m_printOut;
  }
  return StatusCode::SUCCESS;
}
 
 
//----------------------------------------------------------------------------
 
void MrpcRec::clearTofTrackVec( std::vector<MrpcTrack*>*& tofTrackVec) {
  if( tofTrackVec ) {
    std::vector<MrpcTrack*>::iterator iter = tofTrackVec->begin();
    for( ; iter < tofTrackVec->end(); iter++ ) {
      delete (*iter);
    }
    tofTrackVec->clear();
    delete tofTrackVec;
  }
  return;
}