MdcxTrackFinder Class Reference

#include <MdcxTrackFinder.h>

Inheritance diagram for MdcxTrackFinder:

Public Member Functions
	MdcxTrackFinder (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~MdcxTrackFinder ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
StatusCode	beginRun ()

Detailed Description

Definition at line 60 of file MdcxTrackFinder.h.

Constructor & Destructor Documentation

MdcxTrackFinder()

MdcxTrackFinder::MdcxTrackFinder	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 107 of file MdcxTrackFinder.cxx.

                                                                                :
  Algorithm(name, pSvcLocator), m_mdcCalibFunSvc(0)
{
  //input
  declareProperty("pdtFile",      m_pdtFile = "pdt.table");
  //debug control
  declareProperty("debug",    m_debug= 0);
  declareProperty("hist",     m_hist= 0);
  declareProperty("mcHist",   m_mcHist = false);
  //cuts and control
  declareProperty("cresol",   m_cresol = 0.013);
 
  declareProperty("getDigiFlag",  m_getDigiFlag = 0);
  declareProperty("maxMdcDigi",   m_maxMdcDigi= 0);
  declareProperty("keepBadTdc",   m_keepBadTdc= 0);
  declareProperty("dropHot",      m_dropHot= 0);
  declareProperty("keepUnmatch",  m_keepUnmatch= 0);
  declareProperty("salvageTrk",   m_salvageTrk = false);
  declareProperty("dropMultiHotInLayer",m_dropMultiHotInLayer = false);
  declareProperty("dropTrkPt",    m_dropTrkPt = -999.);
  declareProperty("d0Cut",        m_d0Cut = 999.);
  declareProperty("z0Cut",        m_z0Cut = 999.);
 
  declareProperty("minMdcDigi",   m_minMdcDigi = 0);
  declareProperty("countPropTime",m_countPropTime = true);
  declareProperty("addHitCut",    m_addHitCut = 5.);
  declareProperty("dropHitsSigma",m_dropHitsSigma);
  declareProperty("helixFitCut",  m_helixFitCut);
  declareProperty("minTrkProb",   m_minTrkProb = 0.01);
  declareProperty("csmax4",   m_csmax4 = 50.);
  declareProperty("csmax3",   m_csmax3 = 1.);
  declareProperty("helixFitSigma",m_helixFitSigma= 5.);
  declareProperty("maxRcsInAddSeg",m_maxRcsInAddSeg= 50.);
  declareProperty("nSigAddHitTrk", m_nSigAddHitTrk= 5.);
  declareProperty("maxProca",      m_maxProca= 0.6);
  declareProperty("doSag",         m_doSag= false);
  declareProperty("lineFit",       m_lineFit = false);
  //declareProperty("cosmicFit",     m_cosmicFit= false);
}

~MdcxTrackFinder()

MdcxTrackFinder::~MdcxTrackFinder ( )

virtual

Definition at line 150 of file MdcxTrackFinder.cxx.

                                  {
  delete m_bfield;
}

Member Function Documentation

beginRun()

StatusCode MdcxTrackFinder::beginRun

(

)

Definition at line 154 of file MdcxTrackFinder.cxx.

                                    {  
  // Get Mdc Detector Geometry
  m_gm = MdcDetector::instance(m_doSag); 
  if(NULL == m_gm) return StatusCode::FAILURE;
  MdcxHit::setMdcDetector(m_gm);
 
  return StatusCode::SUCCESS;
}

execute()

StatusCode MdcxTrackFinder::execute

(

)

Definition at line 248 of file MdcxTrackFinder.cxx.

                                    {
 
 
  b_saveEvent=false;
  setFilterPassed(b_saveEvent);
#ifdef MDCXTIMEDEBUG
  m_timer[0]->start();
  m_timer[1]->start();
#endif
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in execute()" << endreq;
  StatusCode sc;
 
  nTk = 0; t_nTdsTk = 0; t_nDigi=0; t_nSeg=0; //yzhang  for fill 
  //------------------------------------
  // Get event No.
  //------------------------------------
  SmartDataPtr<Event::EventHeader> evtHead(eventSvc(),"/Event/EventHeader");
  if (!evtHead) {
    log << MSG::FATAL<< "Could not retrieve event header" << endreq;
    return StatusCode::FAILURE;
  } 
  m_eventNo = evtHead->eventNumber();
  if(m_debug>0)std::cout << "x evt: "<<evtHead->runNumber()<<" " << m_eventNo<< std::endl;
  long t_evtNo = m_eventNo;
  g_eventNo = m_eventNo;
  //if (t_evtNo % 1000 == 0) std::cout << "x evt: " << t_evtNo << std::endl;
  IDataManagerSvc *dataManSvc;
  DataObject *aTrackCol;
  DataObject *aHitCol;
  if (!m_salvageTrk) { 
    SmartIF<IDataManagerSvc> dataManSvc(eventSvc()); 
    eventSvc()->findObject("/Event/Recon/RecMdcTrackCol",aTrackCol);
    if(aTrackCol != NULL) {
      dataManSvc->clearSubTree("/Event/Recon/RecMdcTrackCol");
      eventSvc()->unregisterObject("/Event/Recon/RecMdcTrackCol");
    }
    eventSvc()->findObject("/Event/Recon/RecMdcHitCol",aHitCol);
    if(aHitCol != NULL) {
      dataManSvc->clearSubTree("/Event/Recon/RecMdcHitCol");
      eventSvc()->unregisterObject("/Event/Recon/RecMdcHitCol");
    }
  }
 
  //------------------------------------
  // Initialize track collection in TDS
  //------------------------------------
  DataObject *aReconEvent;
  eventSvc()->findObject("/Event/Recon",aReconEvent);
  if (aReconEvent==NULL) {
    aReconEvent = new ReconEvent();
    sc = eventSvc()->registerObject("/Event/Recon",aReconEvent);
    if(sc != StatusCode::SUCCESS) {
      log << MSG::FATAL << "Could not register ReconEvent" <<endreq;
      return StatusCode::FAILURE;
    }
  }
  RecMdcTrackCol* trackList;
  eventSvc()->findObject("/Event/Recon/RecMdcTrackCol",aTrackCol);
  if (aTrackCol) {
    trackList = dynamic_cast<RecMdcTrackCol*> (aTrackCol);
  }else{
    trackList = new RecMdcTrackCol;
    sc =  eventSvc()->registerObject(EventModel::Recon::RecMdcTrackCol, trackList);
    if(!sc.isSuccess()) {
      log << MSG::FATAL << " Could not register RecMdcTrack collection" <<endreq;
      return StatusCode::FAILURE;
    }
  }
  RecMdcHitCol* hitList;
  eventSvc()->findObject("/Event/Recon/RecMdcHitCol",aHitCol);
  if (aHitCol) {
    hitList = dynamic_cast<RecMdcHitCol*> (aHitCol);
  }else{
    hitList = new RecMdcHitCol;
    sc =  eventSvc()->registerObject(EventModel::Recon::RecMdcHitCol, hitList);
    if(!sc.isSuccess()) {
      log << MSG::FATAL << " Could not register RecMdcHit collection" <<endreq;
      return StatusCode::FAILURE;
    }
  }
 
  //------------------------------------
  // Initialize hit collection in TDS
  //------------------------------------
  DataObject *pnode = 0;
  sc = eventSvc()->retrieveObject("/Event/Hit",pnode);
  if(!sc.isSuccess()) {
    pnode = new DataObject;
    sc = eventSvc()->registerObject("/Event/Hit",pnode);
    if(!sc.isSuccess()) {
      log << MSG::FATAL << " Could not register /Event/Hit branch " <<endreq;
      return StatusCode::FAILURE;
    }
  }
  SmartDataPtr<MdcHitCol> m_hitCol(eventSvc(), "/Event/Hit/MdcHitCol");
  if (!m_hitCol){
    m_hitCol= new MdcHitCol;
    sc = eventSvc()->registerObject("/Event/Hit/MdcHitCol",m_hitCol);
    if(!sc.isSuccess()) {
      log << MSG::FATAL << " Could not register hit collection" <<endreq;
      return StatusCode::FAILURE;
    }
  } 
 
 
  //------------------------------------
  // Get bunch time t0 (ns) and timing
  //------------------------------------
  m_bunchT0 = -999.;
  SmartDataPtr<RecEsTimeCol> aevtimeCol(eventSvc(),"/Event/Recon/RecEsTimeCol");
  if (!aevtimeCol || aevtimeCol->size()==0) {
    log << MSG::WARNING<< "evt "<<m_eventNo<<" Could not find RecEsTimeCol"<< endreq;
    return StatusCode::SUCCESS;
  }
 
  RecEsTimeCol::iterator iter_evt = aevtimeCol->begin();
  for(; iter_evt!=aevtimeCol->end(); iter_evt++){
    m_bunchT0 =  (*iter_evt)->getTest();
    m_t0Stat = (*iter_evt)->getStat();
    if(m_debug>1) std::cout<<name()<<" "<<t_evtNo<<" t0  "<<m_bunchT0<<" t0Stat  "<<m_t0Stat<<std::endl;
    if ((m_t0Stat==0) || (m_bunchT0 < 0.) || (m_bunchT0 > 9999.0) ){
      log << MSG::WARNING << "Skip evt:"<<m_eventNo<< " by  t0 = "<<m_bunchT0 << endreq;
      //return StatusCode::SUCCESS;
    }
  }
  if(m_debug>1) std::cout<<name()<<" evt "<<t_evtNo<<" t0  "<<m_bunchT0<<" t0Stat  "<<m_t0Stat<<std::endl;
  int trigtiming=-10;
  SmartDataPtr<TrigData> trigData(eventSvc(),"/Event/Trig/TrigData");
  if(trigData){
    log << MSG::INFO <<"Trigger conditions 0--43:"<<endreq;
    for(int i = 0; i < 48; i++) {
      log << MSG::INFO << trigData->getTrigCondName(i)<<" ---- "<<trigData->getTrigCondition(i)<< endreq;
    }
    for(int i = 0; i < 16; i++) log << MSG::INFO << "Trigger channel "<< i << ": " << trigData->getTrigChannel(i) << endreq;
    m_timing=trigData->getTimingType();
    //cout<<"-----------------trigger timing type-----------------------: "<<trigtiming<<endl;
    log << MSG::INFO <<"Tigger Timing type: "<< trigtiming << endreq;
  }
 
  //------------------------------------
  //  Initialize MdcxHits
  //------------------------------------
  m_mdcxHits.reset();
  uint32_t getDigiFlag = 0;
  getDigiFlag += m_maxMdcDigi;
  if(m_dropHot||m_salvageTrk) getDigiFlag |= MdcRawDataProvider::b_dropHot;
  if(m_keepBadTdc)  getDigiFlag |= MdcRawDataProvider::b_keepBadTdc;
  if(m_keepUnmatch) getDigiFlag |= MdcRawDataProvider::b_keepUnmatch;
  mdcDigiVec = m_rawDataProviderSvc->getMdcDigiVec(getDigiFlag);
  t_nDigi = mdcDigiVec.size();
 
  // fill Mc truth
  //if(m_hist) fillMcTruth();
 
  //skip event by hit numbe
  if (t_nDigi < m_minMdcDigi){
    if (0 == t_nDigi ){
      log << MSG::WARNING << " No hits in MdcDigiVec" << endreq;
    }
    log << MSG::WARNING << " Skip this event for MdcDigiVec.size() < "<<m_minMdcDigi << endreq;
    return StatusCode::SUCCESS;
  }
  m_mdcxHits.create(mdcDigiVec, m_bunchT0, m_cresol); 
  const HepAList<MdcxHit>& dchitlist = m_mdcxHits.GetMdcxHitList();
 
  if(m_debug>2) m_mdcxHits.print(std::cout,6796);
 
  //--------------------------------------------
  //  Make segments (MdcxSeg's) out of MdcxHit's
  //-------------------------------------------- 
  MdcxFindSegs dcsegs(dchitlist,m_debug);
  const HepAList<MdcxSeg>& seglist = dcsegs.GetMdcxSeglist();
  if(m_debug > 1 ){ dumpMdcxSegs(seglist);}
  t_nSeg = seglist.length();
  //if(m_hist){ fillMdcxSegs(seglist);}
 
#ifdef MDCXTIMEDEBUG
  m_timer[1]->stop();
  m_timer[2]->start();
#endif
  //--------------------------------------------
  //  Make tracks (MdcxFittedHel's) out of MdcxSeg's
  //--------------------------------------------
  MdcxFindTracks dctrks(seglist,m_debug);
  HepAList<MdcxFittedHel>& firsttrkl = (HepAList<MdcxFittedHel>&)dctrks.GetMdcxTrklist();
  if(m_debug>1) dumpTrackList(firsttrkl);
 
#ifdef MDCXTIMEDEBUG
  m_timer[2]->stop();
  m_timer[3]->start();
#endif
  //if(m_hist){ fillTrkl(firsttrkl);}
 
  //if(m_debug>1){
  //  std::cout << "dchitlist after find tracks before MergeDups, nhits=" << dchitlist.length() << std::endl;
  //  for (int ii = 0; ii < dchitlist.length(); ii++) {
  //    dchitlist[ii]->print(std::cout, ii);
  //  }
  //  std::cout<<std::endl;
  //}
  MdcxMergeDups dcmergeem(firsttrkl,m_debug);
  HepAList<MdcxFittedHel>& trkl = (HepAList<MdcxFittedHel>&)dcmergeem.GetMergedTrklist();
 
  //if (m_debug > 1 ){
  //  cout << "MdcxTrackFinder: after MergeDups, have "
  //  << trkl.length() << " track(s). nhits=" << dchitlist.length() << endl;
  //  for (int ii = 0; ii < dchitlist.length(); ii++) {
  //    dchitlist[ii]->print(std::cout, ii);
  //  }
  //  std::cout<<std::endl;
  //}
 
  //---------------------------------------------------------
  //  Put my tracks into official fitter and store to TDS 
  //---------------------------------------------------------- 
 
 
  sc = FitMdcxTrack(trkl, dchitlist, m_hitCol, trackList, hitList);
  if (!sc.isSuccess()) {return StatusCode::SUCCESS;}
  t_nTdsTk = trackList->size();
 
  t_nTkTot += trackList->size();
  if(t_nTdsTk<20) t_nTkNum[t_nTdsTk]++;
 
#ifdef MDCXTIMEDEBUG
  m_timer[0]->stop();
  m_timer[3]->stop();
#endif
 
  if(m_hist) fillEvent();
  if (m_debug > 0) {
    DataObject* pNode;
    eventSvc()->retrieveObject("/Event/Recon/RecMdcTrackCol",pNode);
    RecMdcTrackCol *tmpTrackCol = dynamic_cast<RecMdcTrackCol*> (pNode);
    eventSvc()->retrieveObject("/Event/Recon/RecMdcHitCol",pNode);
    int nTdsTk = 0;
    if(tmpTrackCol) nTdsTk = tmpTrackCol->size(); 
 
    //if (t_evtNo % 1000 == 0) {
    std::cout<< "MdcxTrackFinder: evtNo "<< m_eventNo << " t0="<<m_bunchT0
      <<" Found " <<trkl.length() 
      <<" keep "<< t_nTdsTk
      <<" finialy keep "<< nTdsTk;
 
    int ndelete =0; trkl.length() - trackList->size();
    if( ndelete>0 ) std::cout <<" delete "<< ndelete;
    std::cout <<" track(s)" <<endl;
    //}
 
    if(m_debug>1)dumpTdsTrack(tmpTrackCol);
    if(m_debug>1)dumpTrack(tmpTrackCol);
    //dumpTdsHits(tmpHitCol);
 
  }
  if((trackList->size()!=4) ) b_saveEvent = true;
  setFilterPassed(b_saveEvent); 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode MdcxTrackFinder::finalize

(

)

Definition at line 508 of file MdcxTrackFinder.cxx.

                                     {
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in finalize()" << endreq;
 
  std::cout<< " --after " << name() << " keep " << t_nTkTot<< " tracks  "<<std::endl;
  for(int i=0; i<20; i++){
    if(t_nTkNum[i]>0)std::cout<< " nTk="<< i << " "<< t_nTkNum[i]<< std::endl;
  }
 
  //tot evtNo, trkNum
  return StatusCode::SUCCESS;
}

initialize()

StatusCode MdcxTrackFinder::initialize

(

)

Definition at line 165 of file MdcxTrackFinder.cxx.

                                      {  
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in initialize()" << endreq;  
 
  t_nTkTot = 0;
  for (int i=0;i<20;i++) t_nTkNum[i]=0;
 
  //m_flags.readPar(m_paramFile);
#ifdef MDCXTIMEDEBUG
  StatusCode tsc = service( "BesTimerSvc", m_timersvc);
  if( tsc.isFailure() ) {
    log << MSG::WARNING << name() << ": Unable to locate BesTimer Service" << endreq;
    return StatusCode::FAILURE;
  }
  m_timer[0] = m_timersvc->addItem("Execution");
  m_timer[0]->propName("Execution");
  m_timer[1] = m_timersvc->addItem("findSeg");
  m_timer[1]->propName("findSeg");
  m_timer[2] = m_timersvc->addItem("findTrack");
  m_timer[2]->propName("findTrack");
  m_timer[3] = m_timersvc->addItem("fitting");
  m_timer[3]->propName("fitting");
#endif
 
  if (m_helixFitCut.size() == 43){
    for(int i=0; i<43; i++){
      //MdcTrkReconCut_helix_fit[i] = m_helixFitCut[i]; 
      TrkHelixFitter::nSigmaCut[i] = m_helixFitCut[i];
    }
  }
  MdcxParameters::debug = m_debug;
  MdcxParameters::minTrkProb = m_minTrkProb;
  MdcxParameters::csmax4 = m_csmax4;
  MdcxParameters::csmax3 = m_csmax3;
  MdcxParameters::helixFitSigma = m_helixFitSigma;
  MdcxParameters::maxRcsInAddSeg= m_maxRcsInAddSeg;
  MdcxParameters::nSigAddHitTrk = m_nSigAddHitTrk;
  MdcxParameters::maxProca      = m_maxProca;
  TrkHelixFitter::m_debug       = (m_debug>7);
  Pdt::readMCppTable(m_pdtFile); 
  MdcxFittedHel::debug = m_debug;
 
 
  // Get MdcCalibFunSvc
  IMdcCalibFunSvc* imdcCalibSvc; 
  StatusCode sc = service ("MdcCalibFunSvc", imdcCalibSvc);
  m_mdcCalibFunSvc = dynamic_cast<MdcCalibFunSvc*>(imdcCalibSvc);
  if ( sc.isFailure() ){
    log << MSG::FATAL << "Could not load MdcCalibFunSvc!" << endreq;
    return StatusCode::FAILURE;
  }
  MdcxHit::setMdcCalibFunSvc(m_mdcCalibFunSvc);
  MdcxHit::setCountPropTime(m_countPropTime);
 
  // Get RawDataProviderSvc
  IRawDataProviderSvc* iRawDataProvider; 
  sc = service ("RawDataProviderSvc", iRawDataProvider);
  if ( sc.isFailure() ){
    log << MSG::FATAL << "Could not load RawDataProviderSvc!" << endreq;
    return StatusCode::FAILURE;
  }
  m_rawDataProviderSvc = dynamic_cast<RawDataProviderSvc*>(iRawDataProvider);
 
 
  //Initailize magnetic filed 
  sc = service ("MagneticFieldSvc",m_pIMF);
  if(sc!=StatusCode::SUCCESS) {
    log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq;
  }
  m_bfield = new BField(m_pIMF);
  log << MSG::INFO << "field z = "<<m_bfield->bFieldNominal()<< endreq;
  m_context = new TrkContextEv(m_bfield);
 
  if (m_hist) {bookNTuple();}
  if (m_dropHitsSigma.size()==43){
    for (int ii=0;ii<43;ii++) {
      MdcxParameters::dropHitsSigma[ii]=m_dropHitsSigma[ii];
    }
  }
 
  return StatusCode::SUCCESS;
}

---

The documentation for this class was generated from the following files:

• MdcxTrackFinder.h
• MdcxTrackFinder.cxx