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 62 of file MdcxTrackFinder.h.

Constructor & Destructor Documentation

MdcxTrackFinder()

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

Definition at line 106 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);
}

Referenced by MdcxTrackFinder().

~MdcxTrackFinder()

MdcxTrackFinder::~MdcxTrackFinder ( )

virtual

Definition at line 148 of file MdcxTrackFinder.cxx.

                                  {
  if ( m_bfield ) delete m_bfield;
}

Member Function Documentation

beginRun()

StatusCode MdcxTrackFinder::beginRun

(

)

Definition at line 152 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;
}

Referenced by execute().

execute()

StatusCode MdcxTrackFinder::execute

(

)

Definition at line 244 of file MdcxTrackFinder.cxx.

                                    {
  if ( !m_beginRun )
  {
    StatusCode sc = beginRun();
    if ( sc.isFailure() )
    {
      error() << "beginRun failed" << endmsg;
      return StatusCode::FAILURE;
    }
    m_beginRun = true;
  }
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in execute()" << endmsg;
  StatusCode sc;
 
  b_saveEvent = false;
  setFilterPassed( b_saveEvent );
 
#ifdef MDCXTIMEDEBUG
  m_timer[0]->start();
  m_timer[1]->start();
#endif
 
  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" << endmsg;
    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 )
    {
      dataManSvc->clearSubTree( "/Event/Recon/RecMdcTrackCol" );
      eventSvc()->unregisterObject( "/Event/Recon/RecMdcTrackCol" );
    }
    eventSvc()->findObject( "/Event/Recon/RecMdcHitCol", aHitCol );
    if ( aHitCol )
    {
      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" << endmsg;
      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" << endmsg;
      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" << endmsg;
      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 " << endmsg;
      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" << endmsg;
      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" << endmsg;
    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 << endmsg;
      // 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:" << endmsg;
    for ( int i = 0; i < 48; i++ )
    {
      log << MSG::INFO << trigData->getTrigCondName( i ) << " ---- "
          << trigData->getTrigCondition( i ) << endmsg;
    }
    for ( int i = 0; i < 16; i++ )
      log << MSG::INFO << "Trigger channel " << i << ": " << trigData->getTrigChannel( i )
          << endmsg;
    m_timing = trigData->getTimingType();
    // cout<<"-----------------trigger timing type-----------------------: "<<trigtiming<<endl;
    log << MSG::INFO << "Tigger Timing type: " << trigtiming << endmsg;
  }
 
  //------------------------------------
  //  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" << endmsg; }
    log << MSG::WARNING << " Skip this event for MdcDigiVec.size() < " << m_minMdcDigi
        << endmsg;
    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 541 of file MdcxTrackFinder.cxx.

                                     {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
 
  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 163 of file MdcxTrackFinder.cxx.

                                       {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in initialize()" << endmsg;
 
  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" << endmsg;
    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
  StatusCode sc = service( "MdcCalibFunSvc", m_mdcCalibFunSvc );
  if ( sc.isFailure() )
  {
    log << MSG::FATAL << "Could not load MdcCalibFunSvc!" << endmsg;
    return StatusCode::FAILURE;
  }
  MdcxHit::setMdcCalibFunSvc( m_mdcCalibFunSvc );
  MdcxHit::setCountPropTime( m_countPropTime );
 
  // Get RawDataProviderSvc
  sc = service( "RawDataProviderSvc", m_rawDataProviderSvc );
  if ( sc.isFailure() )
  {
    log << MSG::FATAL << "Could not load RawDataProviderSvc!" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Initailize magnetic filed
  sc = service( "MagneticFieldSvc", m_pIMF );
  if ( sc != StatusCode::SUCCESS )
  { log << MSG::ERROR << "Unable to open Magnetic field service" << endmsg; }
  m_bfield = new BField( m_pIMF );
  log << MSG::INFO << "field z = " << m_bfield->bFieldNominal() << endmsg;
  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