#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.