#include <TTUTrackingAlg.h>

Inheritance diagram for TTUTrackingAlg:

Classes
struct	CompareMechanism

class	Seed

class	Track

Public Member Functions
bool	process (const TTUInput &) override

void	setBoardSpecs (const TTUBoardSpecs::TTUBoardConfig &) override

void	setMinTrkLength (int val)

	TTUTrackingAlg ()
	Standard constructor. More...

	~TTUTrackingAlg () override
	Destructor. More...

Public Member Functions inherited from TTULogic
virtual void	setOption (int option)

virtual	~TTULogic ()

Private Member Functions
void	alignTracks ()

void	cleanUp ()

int	executeTracker (Track , std::vector< Seed > &)

void	filter (Track , std::vector< Seed > &)

void	findNeighbors (Seed , std::vector< Seed > &)

void	ghostBuster (Track *)

void	print (const std::vector< Seed * > &seeds)

void	runSeedBuster (const TTUInput &)

Private Attributes
bool	m_debug

std::vector< std::unique_ptr< Seed > >	m_initialseeds

int	m_mintrklength

int	m_SEscanorder [12]

int	m_STscanorder [6]

std::vector< std::unique_ptr< Track > >	m_tracks

Additional Inherited Members
Public Attributes inherited from TTULogic
int	m_option

bool	m_triggersignal

Detailed Description

Tracking Algorithm [ref 2]

ref 2: "A configurable Tracking Algorithm to detect cosmic muon tracks for the CMS-RPC based Technical Trigger", R.T.Rajan et al

Author: Andres Osorio

email: aosor.nosp@m.io@u.nosp@m.niand.nosp@m.es.e.nosp@m.du.co

Date: 2008-10-18

Definition at line 25 of file TTUTrackingAlg.h.

Constructor & Destructor Documentation

TTUTrackingAlg::TTUTrackingAlg ( )

Standard constructor.

Definition at line 18 of file TTUTrackingAlg.cc.

References mps_fire::i, m_debug, m_mintrklength, m_SEscanorder, m_STscanorder, and TTULogic::m_triggersignal.

                                  {
 
   int StOrder[6]={6,5,4,3,2,1};
   int SeOrder[12]={4,5,3,6,2,7,1,8,12,9,11,10};
   
   for(int i=0; i < 6; ++i) 
   {
     m_STscanorder[i]       = StOrder[i];
     m_SEscanorder[i*2]     = SeOrder[i*2];
     m_SEscanorder[(i*2)+1] = SeOrder[(i*2)+1];
   }
   
   m_triggersignal = false;
   m_mintrklength = 4;
 
   m_debug = false;
   
 }

TTUTrackingAlg::~TTUTrackingAlg ( )

override

Destructor.

Definition at line 40 of file TTUTrackingAlg.cc.

40 {

41 }

Member Function Documentation

void TTUTrackingAlg::alignTracks ( )

private

Definition at line 276 of file TTUTrackingAlg.cc.

References compare(), gather_cfg::cout, m_debug, m_tracks, and groupFilesInBlocks::reverse.

Referenced by TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
 
   CompareMechanism<std::unique_ptr<Track>> compare;
   
   std::sort( m_tracks.begin(), m_tracks.end(), compare );
   std::reverse( m_tracks.begin(), m_tracks.end() );
   
   if( m_debug ) {
     for( auto& tr : m_tracks)
       std::cout << "Align tracks> trk len: " << tr->length() << " ";
     std::cout << std::endl;
   }
   
 }

void TTUTrackingAlg::cleanUp ( )

private

Definition at line 292 of file TTUTrackingAlg.cc.

References m_initialseeds, and m_tracks.

Referenced by TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
   
   m_tracks.clear();
   m_initialseeds.clear();
   
 }

int TTUTrackingAlg::executeTracker	(	Track *	_trk,
		std::vector< Seed * > &	neighbors
	)

private

Definition at line 161 of file TTUTrackingAlg.cc.

References TTUTrackingAlg::Track::add(), gather_cfg::cout, filter(), findNeighbors(), and m_debug.

Referenced by TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
   
   if ( m_debug ) std::cout << "executeTracker: " << neighbors.size() << std::endl;
   
   //...
   
   auto _itr = neighbors.begin();
   
   while( _itr != neighbors.end() ) {
   
     _trk->add( (*_itr) );
     
     std::vector<Seed*> _nextneighbors;
     
     findNeighbors( (*_itr) , _nextneighbors );
     
     filter( _trk, _nextneighbors );
     
     if ( _nextneighbors.size() == 1 ) 
       executeTracker( _trk, _nextneighbors );
     
     //... bifurcation not considered at the moment
         
     ++_itr;
     
   }
   
   //...
   
   return 1;
   
 }

void TTUTrackingAlg::filter	(	Track *	_trk,
		std::vector< Seed * > &	_nbrs
	)

private

Definition at line 231 of file TTUTrackingAlg.cc.

References gather_cfg::cout, spr::find(), m_debug, and TTUTrackingAlg::Track::m_seeds.

Referenced by executeTracker(), TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
   
   //... filter: removes from neighbors list, seeds already present
   //...    in tracks
 
   for( auto _itr = _trk->m_seeds.begin();_itr != _trk->m_seeds.end(); ++_itr) 
   {
     auto _isalready = std::find( _nbrs.begin(),_nbrs.end(), (*_itr) );
     
     if( _isalready != _nbrs.end() ) { 
       _nbrs.erase( _isalready ); 
       if( m_debug ) std::cout << "removing ..." << std::endl;
     }
     
     
   }
   
 }

void TTUTrackingAlg::findNeighbors	(	Seed *	_seed,
		std::vector< Seed * > &	neighbors
	)

private

Definition at line 197 of file TTUTrackingAlg.cc.

References funct::abs(), gather_cfg::cout, m_debug, m_initialseeds, TTUTrackingAlg::Seed::m_sectorId, and TTUTrackingAlg::Seed::m_stationId.

Referenced by executeTracker(), TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
   
   neighbors.clear();
   
   int _xo = _seed->m_sectorId;
   int _yo = _seed->m_stationId;
 
   if( m_debug ) std::cout << "X: " << _xo+1 << " Y: " << _yo+1 << std::endl;
   
   auto _itr = m_initialseeds.begin();
   
   while( _itr != m_initialseeds.end() ) {
     
     int _difx    = std::abs( _xo - (*_itr)->m_sectorId );
     int _dify    = std::abs( _yo - (*_itr)->m_stationId );
     
     if (m_debug) std::cout << "difference (x,y): " << _difx << "," << _dify << "\t";
     
     if ( _difx == 11 ) _difx = 1;
     
     if ( ((_difx == 1) && (_dify == 1)) ||
          ((_difx == 1) && (_dify == 0)) ||
          ((_difx == 0) && (_dify == 1)) ) 
       
       neighbors.push_back( (*_itr).get() );
     
     ++_itr;
   }
 
   if (m_debug) std::cout << std::endl;
   
 }

void TTUTrackingAlg::ghostBuster ( Track * currentTrk )

private

Definition at line 252 of file TTUTrackingAlg.cc.

References a, b, TTUTrackingAlg::Seed::m_sectorId, TTUTrackingAlg::Track::m_seeds, TTUTrackingAlg::Seed::m_stationId, tier0::unique(), and TTUTrackingAlg::Track::updateTrkLength().

Referenced by TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
   
   //...do a final check to make sure there are no repeated seeds in track
   
   std::vector<Seed*>::iterator seedItr;
   
   std::sort( currentTrk->m_seeds.begin(), currentTrk->m_seeds.end(), [](const Seed* a, const Seed* b) {
       if (a->m_sectorId == b->m_sectorId) {
         return a->m_stationId < b->m_stationId;
       }
       return a->m_sectorId < b->m_sectorId;
     });
   
   seedItr = std::unique (currentTrk->m_seeds.begin(), currentTrk->m_seeds.end(), [](const Seed* a, const Seed *b) {
       return a->m_sectorId == b->m_sectorId and a->m_stationId == b->m_stationId;
     });
   
   currentTrk->m_seeds.resize(seedItr - currentTrk->m_seeds.begin());
 
   currentTrk->updateTrkLength();
     
 }

void TTUTrackingAlg::print ( const std::vector< Seed * > & seeds )

inlineprivate

Definition at line 145 of file TTUTrackingAlg.h.

References gather_cfg::cout.

   {
     std::vector<Seed*>::const_iterator itr;
     for( itr = seeds.begin(); itr != seeds.end(); ++itr)
       std::cout << (*itr) << '\t';
     std::cout << '\n';
   };

bool TTUTrackingAlg::process ( const TTUInput & inmap )

overridevirtual

Implements TTULogic.

Definition at line 51 of file TTUTrackingAlg.cc.

References alignTracks(), cleanUp(), gather_cfg::cout, executeTracker(), filter(), findNeighbors(), ghostBuster(), TTUInput::m_bx, m_debug, m_initialseeds, m_mintrklength, m_tracks, TTULogic::m_triggersignal, eostools::move(), and runSeedBuster().

Referenced by TTUTwoORLogic::process().

 {
   
   if( m_debug) std::cout << "TTUTrackingAlg>process() starts + bx= " << inmap.m_bx << std::endl;
 
   m_triggersignal = false;
   
   auto  initTrk =std::make_unique<Track>();
   
   //.
   runSeedBuster( inmap );
   
   if ( !m_initialseeds.empty() && m_initialseeds.size() < 20 ) // if too much hits, then cannot process
     initTrk->add( m_initialseeds[0].get() );
   else {
     initTrk->addnone();
     if( m_debug) std::cout << "TTUTrackingAlg>process() ends: no initialseeds" << std::endl;
     return false;
   }
   
   auto trk = m_tracks.emplace_back( std::move(initTrk) ).get();
   
   //..
   auto _seed = m_initialseeds.begin();
   std::vector<Seed*> neighbors;
   
   while ( _seed != m_initialseeds.end() ) {
     
     findNeighbors( (*_seed).get() , neighbors );
     filter( trk, neighbors );
     executeTracker( trk, neighbors );
     ghostBuster( trk );
     
     ++_seed;
     
     if ( _seed != m_initialseeds.end() ) {
       auto initTrk = std::make_unique<Track>();
       initTrk->add((*_seed).get());
       m_tracks.emplace_back( std::move(initTrk) );
       
     }
 
   }
 
   if( m_debug) { 
     std::cout << "Total tracks: " << m_tracks.size() << std::endl;
     for( auto& tr : m_tracks)
       std::cout << "length: " << tr->length() << '\t';
     std::cout << std::endl;
   }
   
   //...
   alignTracks();
   
   //.... Look at the first track and compare its track length
   
   int tracklen(0);
   auto itr = m_tracks.begin();
   if ( itr != m_tracks.end() ) tracklen = (*itr)->length();
   
   if ( tracklen >= m_mintrklength )
     m_triggersignal = true;
   
   if( m_debug ) {
     std::cout << "TTUTrackingAlg> trk len= " 
               << tracklen << '\t' << "triggered: "
               << m_triggersignal << std::endl;
   }
   
   //..... Clean up for next run
   
   cleanUp();
     
   //.......................................................
   
   if( m_debug ) std::cout << "TTUTrackingAlg>process ends" << std::endl;
   
   return true;
   
 }

void TTUTrackingAlg::runSeedBuster ( const TTUInput & inmap )

private

Definition at line 132 of file TTUTrackingAlg.cc.

References gather_cfg::cout, mps_fire::i, training_settings::idx, TTUInput::input_sec, gen::k, m_debug, m_initialseeds, m_SEscanorder, m_STscanorder, and relativeConstraints::station.

Referenced by TTUTrackingAlg::CompareMechanism< T >::operator()(), and process().

 {
   
   int idx(0);
   int idy(0);
 
   for(int i=0; i < 12; ++i) 
   {
     idx = (m_SEscanorder[i] - 1);
     std::bitset<6> station = inmap.input_sec[idx];
     
     if ( ! station.any() ) continue;
     
     for(int k=0; k < 6; ++k ) {
       
       idy = (m_STscanorder[k] - 1);
       bool _hit = station[idy];
       
       if ( _hit ) {
         m_initialseeds.emplace_back(std::make_unique<Seed>(idx, idy, 0) );
       }
     }
   }
   
   //...
   if ( m_debug ) std::cout << "SeedBuster: " << m_initialseeds.size() << std::endl;
     
 }

void TTUTrackingAlg::setBoardSpecs ( const TTUBoardSpecs::TTUBoardConfig & boardspecs )

overridevirtual

Implements TTULogic.

Definition at line 44 of file TTUTrackingAlg.cc.

References m_mintrklength, and TTUBoardSpecs::TTUBoardConfig::m_TrackLength.

Referenced by TTUTwoORLogic::setBoardSpecs().

 {
   
   m_mintrklength = boardspecs.m_TrackLength;
   
 }

void TTUTrackingAlg::setMinTrkLength ( int val )

inline

Definition at line 106 of file TTUTrackingAlg.h.

References m_mintrklength, and heppy_batch::val.

   {
     m_mintrklength = val;
   };

Member Data Documentation

bool TTUTrackingAlg::m_debug

private

Definition at line 151 of file TTUTrackingAlg.h.

Referenced by alignTracks(), executeTracker(), filter(), findNeighbors(), process(), runSeedBuster(), and TTUTrackingAlg().

std::vector<std::unique_ptr<Seed> > TTUTrackingAlg::m_initialseeds

private

Definition at line 143 of file TTUTrackingAlg.h.

Referenced by cleanUp(), findNeighbors(), process(), and runSeedBuster().

int TTUTrackingAlg::m_mintrklength

private

Definition at line 139 of file TTUTrackingAlg.h.

Referenced by process(), setBoardSpecs(), setMinTrkLength(), and TTUTrackingAlg().

int TTUTrackingAlg::m_SEscanorder[12]

private

Definition at line 137 of file TTUTrackingAlg.h.

Referenced by runSeedBuster(), and TTUTrackingAlg().

int TTUTrackingAlg::m_STscanorder[6]

private

Definition at line 135 of file TTUTrackingAlg.h.

Referenced by runSeedBuster(), and TTUTrackingAlg().

std::vector<std::unique_ptr<Track> > TTUTrackingAlg::m_tracks

private

Definition at line 141 of file TTUTrackingAlg.h.

Referenced by alignTracks(), cleanUp(), and process().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation