TTUTrackingAlg Class Reference

#include <TTUTrackingAlg.h>

Inheritance diagram for TTUTrackingAlg:

Classes
struct	CompareMechanism
struct	CompareSeeds
class	Seed
struct	SortByLayer
struct	SortBySector
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::TTUTrackingAlg

(

)

Standard constructor.

Definition at line 16 of file TTUTrackingAlg.cc.

                               {
  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;
}

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

~TTUTrackingAlg()

TTUTrackingAlg::~TTUTrackingAlg ( )

override

Destructor.

Definition at line 35 of file TTUTrackingAlg.cc.

{}

Member Function Documentation

alignTracks()

void TTUTrackingAlg::alignTracks ( )

private

Definition at line 237 of file TTUTrackingAlg.cc.

                                 {
  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;
  }
}

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

Referenced by process().

cleanUp()

void TTUTrackingAlg::cleanUp ( )

private

Definition at line 250 of file TTUTrackingAlg.cc.

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

References m_initialseeds, and m_tracks.

Referenced by process().

executeTracker()

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

private

Definition at line 145 of file TTUTrackingAlg.cc.

                                                                           {
  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;
}

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

Referenced by process().

filter()

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

private

Definition at line 207 of file TTUTrackingAlg.cc.

                                                                {
  //... 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;
    }
  }
}

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

Referenced by executeTracker(), and process().

findNeighbors()

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

private

Definition at line 175 of file TTUTrackingAlg.cc.

                                                                           {
  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;
}

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

Referenced by executeTracker(), and process().

ghostBuster()

void TTUTrackingAlg::ghostBuster ( Track *  currentTrk )

private

Definition at line 222 of file TTUTrackingAlg.cc.

                                                  {
  //...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(), SortBySector());
  std::sort(currentTrk->m_seeds.begin(), currentTrk->m_seeds.end(), SortByLayer());
 
  seedItr = std::unique(currentTrk->m_seeds.begin(), currentTrk->m_seeds.end(), CompareSeeds());
 
  currentTrk->m_seeds.resize(seedItr - currentTrk->m_seeds.begin());
 
  currentTrk->updateTrkLength();
}

References TTUTrackingAlg::Track::m_seeds, tier0::unique(), and TTUTrackingAlg::Track::updateTrkLength().

Referenced by process().

print()

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

inlineprivate

Definition at line 144 of file TTUTrackingAlg.h.

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

References gather_cfg::cout, and InitialStep_cff::seeds.

process()

bool TTUTrackingAlg::process ( const TTUInput &  inmap )

overridevirtual

Implements TTULogic.

Definition at line 42 of file TTUTrackingAlg.cc.

                                                  {
  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;
}

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().

runSeedBuster()

void TTUTrackingAlg::runSeedBuster ( const TTUInput &  inmap )

private

Definition at line 119 of file TTUTrackingAlg.cc.

                                                        {
  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;
}

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

Referenced by process().

setBoardSpecs()

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

overridevirtual

Implements TTULogic.

Definition at line 38 of file TTUTrackingAlg.cc.

                                                                                {
  m_mintrklength = boardspecs.m_TrackLength;
}

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

Referenced by TTUTwoORLogic::setBoardSpecs().

setMinTrkLength()

void TTUTrackingAlg::setMinTrkLength ( int  val )

inline

Definition at line 95 of file TTUTrackingAlg.h.

{ m_mintrklength = val; };

References m_mintrklength, and heppy_batch::val.

Member Data Documentation

m_debug

bool TTUTrackingAlg::m_debug

private

Definition at line 149 of file TTUTrackingAlg.h.

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

m_initialseeds

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

private

Definition at line 126 of file TTUTrackingAlg.h.

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

m_mintrklength

int TTUTrackingAlg::m_mintrklength

private

Definition at line 122 of file TTUTrackingAlg.h.

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

m_SEscanorder

int TTUTrackingAlg::m_SEscanorder[12]

private

Definition at line 120 of file TTUTrackingAlg.h.

Referenced by runSeedBuster(), and TTUTrackingAlg().

m_STscanorder

int TTUTrackingAlg::m_STscanorder[6]

private

Definition at line 118 of file TTUTrackingAlg.h.

Referenced by runSeedBuster(), and TTUTrackingAlg().

m_tracks

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

private

Definition at line 124 of file TTUTrackingAlg.h.

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