TTUTrackingAlg Class Reference

#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 26 of file TTUTrackingAlg.h.

Constructor & Destructor Documentation

TTUTrackingAlg::TTUTrackingAlg

(

)

Standard constructor.

Definition at line 16 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 35 of file TTUTrackingAlg.cc.

{}

Member Function Documentation

void TTUTrackingAlg::alignTracks ( )

private

Definition at line 243 of file TTUTrackingAlg.cc.

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

Referenced by 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 256 of file TTUTrackingAlg.cc.

References m_initialseeds, and m_tracks.

Referenced by process().

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

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

private

Definition at line 145 of file TTUTrackingAlg.cc.

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

Referenced by 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 207 of file TTUTrackingAlg.cc.

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

Referenced by executeTracker(), 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 175 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(), 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 222 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 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 129 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 42 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 119 of file TTUTrackingAlg.cc.

References gather_cfg::cout, mps_fire::i, gpuPixelDoublets::idy, TTUInput::input_sec, isotrackApplyRegressor::k, m_debug, m_initialseeds, m_SEscanorder, m_STscanorder, and relativeConstraints::station.

Referenced by 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 38 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 96 of file TTUTrackingAlg.h.

References m_mintrklength, and hgcalPerformanceValidation::val.

{ m_mintrklength = val; };

Member Data Documentation

bool TTUTrackingAlg::m_debug

private

Definition at line 134 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 127 of file TTUTrackingAlg.h.

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

int TTUTrackingAlg::m_mintrklength

private

Definition at line 123 of file TTUTrackingAlg.h.

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

int TTUTrackingAlg::m_SEscanorder[12]

private

Definition at line 121 of file TTUTrackingAlg.h.

Referenced by runSeedBuster(), and TTUTrackingAlg().

int TTUTrackingAlg::m_STscanorder[6]

private

Definition at line 119 of file TTUTrackingAlg.h.

Referenced by runSeedBuster(), and TTUTrackingAlg().

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

private

Definition at line 125 of file TTUTrackingAlg.h.

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