#include <MMT_Road.h>

Collaboration diagram for MMT_Road:

Public Member Functions
	MMT_Road (const char sector, const int roadSize, const int UpX, const int DownX, const int UpUV, const int DownUV, const int xthr, const int uvthr, const int iroadx, const int iroadu=-1, const int iroadv=-1)

	~MMT_Road ()=default

void	addHits (std::vector< std::shared_ptr< MMT_Hit > > &hits)

double	avgSofX () const

double	avgSofUV (const int uv1, const int uv2) const

bool	checkCoincidences (const int bcwind) const

unsigned int	countHits () const

unsigned int	countRealHits () const

unsigned int	countUVHits (bool flag) const

unsigned int	countXHits (bool flag) const

bool	evaluateLowRes () const

bool	horizontalCheck () const

void	incrementAge (const int bcwind)

const std::vector< MMT_Hit > &	getHitVector () const

char	getSector () const

int	getXthreshold () const

int	getUVthreshold () const

int	iRoadx () const

int	iRoadu () const

int	iRoadv () const

bool	matureCheck (const int bcwind) const

double	mxl () const

void	reset ()

bool	stereoCheck () const

Private Attributes
std::vector< MMT_Hit >	m_road_hits

double	m_slopeXlow

double	m_slopeXhigh

double	m_slopeUlow

double	m_slopeUhigh

double	m_slopeVlow

double	m_slopeVhigh

int	m_iroadx

int	m_iroadu

int	m_iroadv

int	m_xthr

int	m_uvthr

char	m_sector

Detailed Description

Definition at line 12 of file MMT_Road.h.

Constructor & Destructor Documentation

◆ MMT_Road()

MMT_Road::MMT_Road	(	const char	sector,
		const int	roadSize,
		const int	UpX,
		const int	DownX,
		const int	UpUV,
		const int	DownUV,
		const int	xthr,
		const int	uvthr,
		const int	iroadx,
		const int	iroadu = `-1`,
		const int	iroadv = `-1`
	)

Definition at line 7 of file MMT_Road.cxx.

                                                                          :
   m_iroadx(iroadx),
   m_iroadu(iroadu != -1 ? iroadu : iroadx),
   m_iroadv(iroadv != -1 ? iroadv : iroadx),
   m_xthr(xthr),
   m_uvthr(uvthr),
   m_sector(sector)
 {
   // Pre-calculate slopes
   m_slopeXlow  = roadSize*m_iroadx     + 0.5 - DownX;
   m_slopeXhigh = roadSize*(m_iroadx+1) + 0.5 + UpX;
  
   m_slopeUlow  = roadSize*m_iroadu     + 0.5 - DownUV;
   m_slopeUhigh = roadSize*(m_iroadu+1) + 0.5 + UpUV;
  
   m_slopeVlow  = roadSize*m_iroadv     + 0.5 - DownUV;
   m_slopeVhigh = roadSize*(m_iroadv+1) + 0.5 + UpUV;
 }

◆ ~MMT_Road()

MMT_Road::~MMT_Road ( )

default

Member Function Documentation

◆ addHits()

void MMT_Road::addHits ( std::vector< std::shared_ptr< MMT_Hit > > & hits )

Definition at line 29 of file MMT_Road.cxx.

                                                                {
   for (const auto &hit_i : hits) {
     if (m_sector != hit_i->getSector()) continue;
  
     double slow, shigh;
     if (hit_i->isX()) {
       slow = hit_i->getShift() + m_slopeXlow * hit_i->getPitchOverZ();
       shigh = hit_i->getShift() + m_slopeXhigh * hit_i->getPitchOverZ();
     }
     else if (hit_i->isU()) {
       slow = hit_i->getShift() + m_slopeUlow * hit_i->getPitchOverZ();
       shigh = hit_i->getShift() + m_slopeUhigh * hit_i->getPitchOverZ();
     }
     else if (hit_i->isV()) {
       slow = hit_i->getShift() + m_slopeVlow * hit_i->getPitchOverZ();
       shigh = hit_i->getShift() + m_slopeVhigh * hit_i->getPitchOverZ();
     }
     else continue;
  
     const double val = hit_i->getRZSlope();
     bool has_hit = (val > 0.) ? (val > slow && val < shigh) : (val > shigh && val < slow);
  
     if (!has_hit) continue;
  
     has_hit = false;
     const int bo = hit_i->getPlane();
     auto it = std::find_if(m_road_hits.begin(), m_road_hits.end(), [&bo](const auto &hit) { return (hit.getPlane() == bo); });
     if (it != m_road_hits.end()) {
       has_hit = true;
       if (!hit_i->isNoise() && it->isNoise()) {
         m_road_hits.erase(it);
         has_hit = false;
       }
     }
  
     if (has_hit) continue;
     m_road_hits.emplace_back(*hit_i.get());
     m_road_hits.back().setAge(0);
   }
 }

◆ avgSofUV()

double MMT_Road::avgSofUV	(	const int	uv1,
		const int	uv2
	)		const

Definition at line 82 of file MMT_Road.cxx.

                                                             {
   double sum = 0;
   int N = 0;
   for (const auto &hit : m_road_hits) {
     const int bo = hit.getPlane();
     if (bo == uv1 || bo == uv2) {
       sum += hit.getRZSlope();
       ++N;
     }
   }
   return sum/N;
 }

◆ avgSofX()

double MMT_Road::avgSofX ( ) const

Definition at line 70 of file MMT_Road.cxx.

                                {
   double sum = 0;
   int N = 0;
   for (const auto &hit : m_road_hits) {
     if (hit.isX()) {
       sum += hit.getRZSlope();
       ++N;
     }
   }
   return sum/N;
 }

◆ checkCoincidences()

bool MMT_Road::checkCoincidences ( const int bcwind ) const

inline

Definition at line 21 of file MMT_Road.h.

                                                    {
       return horizontalCheck() && stereoCheck() && matureCheck(bcwind);
     }

◆ countHits()

unsigned int MMT_Road::countHits ( ) const

inline

Definition at line 24 of file MMT_Road.h.

24 { return m_road_hits.size(); }

◆ countRealHits()

unsigned int MMT_Road::countRealHits ( ) const

Definition at line 95 of file MMT_Road.cxx.

                                            {
   return std::count_if(m_road_hits.begin(), m_road_hits.end(),
                        [&](auto& hit) { return hit.isNoise()==false; });
 }

◆ countUVHits()

unsigned int MMT_Road::countUVHits ( bool flag ) const

Definition at line 100 of file MMT_Road.cxx.

                                                   {
   return std::count_if(m_road_hits.begin(), m_road_hits.end(),
                        [&](auto& hit) { return (hit.isU() || hit.isV()) && hit.isNoise()==flag; });
 }

◆ countXHits()

unsigned int MMT_Road::countXHits ( bool flag ) const

Definition at line 105 of file MMT_Road.cxx.

                                                  {
   return std::count_if(m_road_hits.begin(), m_road_hits.end(),
                        [&](auto& hit) { return hit.isX() && hit.isNoise()==flag; });
 }

◆ evaluateLowRes()

bool MMT_Road::evaluateLowRes ( ) const

Definition at line 110 of file MMT_Road.cxx.

                                     {
   unsigned int nhits1 = 0, nhits2 = 0;
   for (const auto &hit : m_road_hits) {
     nhits1 += hit.getPlane() < 4 && !hit.isNoise();
     nhits2 += hit.getPlane() > 3 && !hit.isNoise();
   }
   return (nhits1 < 4 || nhits2 < 4);
 }

◆ getHitVector()

const std::vector<MMT_Hit>& MMT_Road::getHitVector ( ) const

inline

Definition at line 31 of file MMT_Road.h.

31 { return m_road_hits; }

◆ getSector()

char MMT_Road::getSector ( ) const

inline

Definition at line 32 of file MMT_Road.h.

32 { return m_sector; }

◆ getUVthreshold()

int MMT_Road::getUVthreshold ( ) const

inline

Definition at line 34 of file MMT_Road.h.

34 { return m_uvthr; }

◆ getXthreshold()

int MMT_Road::getXthreshold ( ) const

inline

Definition at line 33 of file MMT_Road.h.

33 { return m_xthr; }

◆ horizontalCheck()

bool MMT_Road::horizontalCheck ( ) const

Definition at line 119 of file MMT_Road.cxx.

                                      {
   int nx1 = 0, nx2 = 0;
   for (const auto &hit : m_road_hits) {
     nx1 += hit.getPlane() >-1 && hit.getPlane() < 2;
     nx2 += hit.getPlane() > 5 && hit.getPlane() < 8;
  
     if (nx1 > 0 && nx2 > 0 && (nx1+nx2) >= m_xthr) return true;
   }
   return false;
 }

◆ incrementAge()

void MMT_Road::incrementAge ( const int bcwind )

Definition at line 130 of file MMT_Road.cxx.

                                             {
   std::vector<unsigned int> old_ihits;
   for (unsigned int j = 0; j < m_road_hits.size(); j++) {
     m_road_hits[j].setAge(m_road_hits[j].getAge() +1);
     if (m_road_hits[j].getAge() > (bcwind-1)) old_ihits.push_back(j);
   }
   for (int j = old_ihits.size()-1; j > -1; j--) m_road_hits.erase(m_road_hits.begin()+j);
 }

◆ iRoadu()

int MMT_Road::iRoadu ( ) const

inline

Definition at line 36 of file MMT_Road.h.

36 { return m_iroadu; }

◆ iRoadv()

int MMT_Road::iRoadv ( ) const

inline

Definition at line 37 of file MMT_Road.h.

37 { return m_iroadv; }

◆ iRoadx()

int MMT_Road::iRoadx ( ) const

inline

Definition at line 35 of file MMT_Road.h.

35 { return m_iroadx; }

◆ matureCheck()

bool MMT_Road::matureCheck ( const int bcwind ) const

Definition at line 139 of file MMT_Road.cxx.

                                                  {
   for (const auto &hit : m_road_hits) {
     if (hit.getAge() == (bcwind - 1)) return true;
   }
   return false;
 }

◆ mxl()

double MMT_Road::mxl ( ) const

Definition at line 146 of file MMT_Road.cxx.

                            {
   std::vector<double> ys, zs;
   for (const auto &hit : m_road_hits) {
     if (hit.isX()) {
       ys.push_back(hit.getR());
       zs.push_back(hit.getZ());
     }
   }
   double mxl = 0;
   double avg_z = std::accumulate(zs.begin(), zs.end(), 0.0)/(double)zs.size();
   double sum_sq_z = std::inner_product(zs.begin(), zs.end(), zs.begin(), 0.0);
   for (unsigned int i = 0; i < ys.size(); i++) mxl += ys[i]*( (zs[i]-avg_z) / (sum_sq_z - zs.size()*std::pow(avg_z,2)) );
  
   return mxl;
 }

◆ reset()

void MMT_Road::reset ( )

Definition at line 162 of file MMT_Road.cxx.

                      {
   m_road_hits.clear();
 }

◆ stereoCheck()

bool MMT_Road::stereoCheck ( ) const

Definition at line 166 of file MMT_Road.cxx.

                                  {
  
   if (m_uvthr == 0) return true;
  
   int nu = 0, nv = 0;
   for (const auto &hit : m_road_hits) {
     nu += hit.isU();
     nv += hit.isV();
  
     if (nu > 0 && nv > 0 && (nu+nv) >= m_uvthr) return true;
   }
   return false;
 }

Member Data Documentation

◆ m_iroadu

int MMT_Road::m_iroadu

private

Definition at line 46 of file MMT_Road.h.

◆ m_iroadv

int MMT_Road::m_iroadv

private

Definition at line 46 of file MMT_Road.h.

◆ m_iroadx

int MMT_Road::m_iroadx

private

Definition at line 46 of file MMT_Road.h.

◆ m_road_hits

std::vector<MMT_Hit> MMT_Road::m_road_hits

private

Definition at line 44 of file MMT_Road.h.

◆ m_sector

char MMT_Road::m_sector

private

Definition at line 48 of file MMT_Road.h.