#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 (const std::vector< std::shared_ptr< MMT_Hit > > &hits)
double	avgSofXUV (const char type) const
bool	checkCoincidences (const int bcwind) const
unsigned int	countHits () const
unsigned int	countUHits () const
unsigned int	countXHits () 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
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 8 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 ( const std::vector< std::shared_ptr< MMT_Hit > > & hits )

Definition at line 30 of file MMT_Road.cxx.

                                                                     {
  for (const auto &hit_i : hits) {
    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 {
      slow = hit_i->getShift() + m_slopeVlow * hit_i->getPitchOverZ();
      shigh = hit_i->getShift() + m_slopeVhigh * hit_i->getPitchOverZ();
    }
 
    const double val = hit_i->getRZSlope();
    bool has_hit = (val > 0.) ? (val > slow && val < shigh) : (val > shigh && val < slow);
    if (!has_hit) continue;
 
    const int pl = hit_i->getPlane();
    if (std::ranges::any_of(m_road_hits, [&pl](const auto &hit) { return (hit.getPlane() == pl); })) continue;
 
    m_road_hits.emplace_back(*hit_i.get());
    m_road_hits.back().setAge(0);
  }
}

◆ avgSofXUV()

double MMT_Road::avgSofXUV ( const char type ) const

Definition at line 58 of file MMT_Road.cxx.

                                                {
  double sum = 0;
  unsigned short int N = 0;
  for (const auto &hit : m_road_hits) {
    if (hit.isX() && type == 'X') {
      sum += hit.getRZSlope();
      ++N;
    }
    else if (hit.isU() && type == 'U') {
      sum += hit.getRZSlope();
      ++N;
    }
    else if (hit.isV() && type == 'V') {
      sum += hit.getRZSlope();
      ++N;
    }
    else continue;
  }
  if (N == 0)[[unlikely]]{
    throw std::runtime_error("MMT_Road::avgSofXUV: N is zero.");
  }
  return sum/N;
}

◆ checkCoincidences()

bool MMT_Road::checkCoincidences ( const int bcwind ) const

inline

Definition at line 20 of file MMT_Road.h.

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

◆ countHits()

unsigned int MMT_Road::countHits ( ) const

inline

Definition at line 23 of file MMT_Road.h.

23{ return m_road_hits.size(); }

◆ countUHits()

unsigned int MMT_Road::countUHits ( ) const

Definition at line 82 of file MMT_Road.cxx.

                                        {
  return std::count_if(m_road_hits.begin(), m_road_hits.end(),
                       [](const auto& hit) { return hit.isU(); });
}

◆ countXHits()

unsigned int MMT_Road::countXHits ( ) const

Definition at line 87 of file MMT_Road.cxx.

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

◆ evaluateLowRes()

bool MMT_Road::evaluateLowRes ( ) const

Definition at line 92 of file MMT_Road.cxx.

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

◆ getHitVector()

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

inline

Definition at line 29 of file MMT_Road.h.

29{ return m_road_hits; }

◆ getSector()

char MMT_Road::getSector ( ) const

inline

Definition at line 30 of file MMT_Road.h.

30{ return m_sector; }

◆ getUVthreshold()

int MMT_Road::getUVthreshold ( ) const

inline

Definition at line 32 of file MMT_Road.h.

32{ return m_uvthr; }

◆ getXthreshold()

int MMT_Road::getXthreshold ( ) const

inline

Definition at line 31 of file MMT_Road.h.

31{ return m_xthr; }

◆ horizontalCheck()

bool MMT_Road::horizontalCheck ( ) const

Definition at line 101 of file MMT_Road.cxx.

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

◆ incrementAge()

void MMT_Road::incrementAge ( const int bcwind )

Definition at line 112 of file MMT_Road.cxx.

                                            {
  unsigned short int old_ihits = 0;
  for (auto &hit : m_road_hits) {
    hit.setAge(hit.getAge()+1);
    if (hit.getAge() > (bcwind-1)) ++old_ihits;
  }
  m_road_hits.erase(m_road_hits.begin(), m_road_hits.begin()+old_ihits);
}

◆ iRoadu()

int MMT_Road::iRoadu ( ) const

inline

Definition at line 34 of file MMT_Road.h.

34{ return m_iroadu; }

◆ iRoadv()

int MMT_Road::iRoadv ( ) const

inline

Definition at line 35 of file MMT_Road.h.

35{ return m_iroadv; }

◆ iRoadx()

int MMT_Road::iRoadx ( ) const

inline

Definition at line 33 of file MMT_Road.h.

33{ return m_iroadx; }

◆ matureCheck()

bool MMT_Road::matureCheck ( const int bcwind ) const

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

◆ stereoCheck()

bool MMT_Road::stereoCheck ( ) const

Definition at line 144 of file MMT_Road.cxx.

                                 {
  unsigned short 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 43 of file MMT_Road.h.

◆ m_iroadv

int MMT_Road::m_iroadv

private

Definition at line 43 of file MMT_Road.h.

◆ m_iroadx

int MMT_Road::m_iroadx

private

Definition at line 43 of file MMT_Road.h.

◆ m_road_hits

std::vector<MMT_Hit> MMT_Road::m_road_hits

private

Definition at line 41 of file MMT_Road.h.

◆ m_sector

char MMT_Road::m_sector

private

Definition at line 45 of file MMT_Road.h.