dt::Cand Class Reference

Calculation and representation of a straight line passing through several "segment" windows. More...

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-12-03/DiscreteTracker/Cand.h"

Public Member Functions
	Cand (geo::View_t view, bool up)
void	AddChunk (const Chunk &chunk, Direction dir)
	Simply store the chunk in the list. Need to call AddSeg too. More...
void	PopFirstChunk ()
void	PopLastChunk ()
bool	operator< (const Cand &rhs) const
void	EstimateStraightLine (double &z1, double &y1, double &z2, double &y2) const
double	MinGradient () const
double	MaxGradient () const
double	EstimateGradient () const
geo::View_t	View () const
unsigned int	NChunks () const
unsigned int	NDeadChunks () const
int	NHitPlanes () const
const Chunk &	FirstChunk () const
const Chunk &	LastChunk () const
const Chunk &	ExtremalChunk (Direction dir) const
bool	IsExtremalChunkComplete (Direction dir) const
void	MarkExtremalChunkShower (Direction dir)
bool	IsAllShower () const
const Segment &	FirstSeg () const
const Segment &	LastSeg () const
const Segment &	ExtremalSeg (Direction dir) const
bool	Up () const
art::PtrVector< rb::CellHit >	AllHits () const
rb::Track	ToTrack () const
std::list< Chunk >	AllChunks () const
	Sorted in plane order. More...
unsigned int	FirstPlane () const
unsigned int	LastPlane () const
unsigned int	ExtremalPlane (Direction dir) const
bool	TryAddSeg (const Segment &seg, Direction dir, bool check=true)
	Appends seg to fSegs and updates internal state reflecting limits on the possible straight lines. If the new seg is impossible to accomodate, returns false and guarantees not to change any state. More...
bool	TryAddSegOutOfOrder (const Segment &seg)
void	PopFirstSeg ()
void	PopLastSeg ()
int	NSegs () const
void	TrimFront ()
void	TrimBack ()
void	ShortenOne (Direction dir)
Cand	MaybeFlip (bool &ok) const
bool	FindChunk (int plane, Chunk &chunk) const
bool	operator== (const Cand &rhs) const

Protected Member Functions
void	MinMaxLines (const Segment &segi, const Segment &segj, double &mmax, double &mmin, double &cmax, double &cmin) const
	Helper for TryAddSeg. More...
void	MinMaxLines (const SubSeg &segi, const SubSeg &segj, double &mmax, double &mmin, double &cmax, double &cmin) const
void	PopSegHelper (const Segment &segi, Direction end)
double	ClosestToEndCell (bool left) const
	Z position. More...
double	MAvg () const
double	CAvg () const

Protected Attributes
geo::View_t	fView
bool	fUp
double	fAllMMax
double	fAllMMin
double	fAllCMax
double	fAllCMin
int	fNChunks
int	fNDeadChunks
std::list< Segment >	fSegs
std::list< Chunk >	fChunks
bool	fAllHitsDirty
art::PtrVector< rb::CellHit >	fAllHits
	Always access via AllHits. More...

Detailed Description

Calculation and representation of a straight line passing through several "segment" windows.

Definition at line 25 of file Cand.h.

Constructor & Destructor Documentation

dt::Cand::Cand	(	geo::View_t	view,
		bool	up
	)

Definition at line 26 of file Cand.cxx.

    : fView(view), fUp(up),
      fAllMMax(+1e10), fAllMMin(-1e10),
      fAllCMax(+1e10), fAllCMin(-1e10),
      fNChunks(0), fNDeadChunks(0),
      fAllHitsDirty(true)
  {
  }

Member Function Documentation

void dt::Cand::AddChunk	(	const Chunk &	chunk,
		Direction	dir
	)

Simply store the chunk in the list. Need to call AddSeg too.

Definition at line 36 of file Cand.cxx.

References ana::assert(), fAllHitsDirty, fChunks, fNChunks, fNDeadChunks, fUp, dt::Chunk::HasHits(), dt::kDownstream, and dt::Chunk::Up().

Referenced by dt::DiscreteTracker::BestSeed(), MaybeFlip(), and dt::DiscreteTracker::TryExtendCandOne().

  {
    fAllHitsDirty = true;

    if(chunk.HasHits())
      ++fNChunks;
    else
      ++fNDeadChunks;
    assert(chunk.Up() == fUp);

    if(dir == kDownstream)
      fChunks.push_back(chunk);
    else
      fChunks.push_front(chunk);
  }

std::list<Chunk> dt::Cand::AllChunks ( ) const

inline

Sorted in plane order.

Definition at line 65 of file Cand.h.

{return fChunks;}

art::PtrVector< rb::CellHit > dt::Cand::AllHits

(

)

const

Definition at line 424 of file Cand.cxx.

References CAvg(), art::PtrVector< T >::clear(), fAllHits, fAllHitsDirty, fChunks, FirstSeg(), fNChunks, fSegs, it, LastChunk(), LastSeg(), dt::Segment::left, m, MAvg(), dt::Chunk::Plane(), art::PtrVector< T >::push_back(), and art::PtrVector< T >::size().

Referenced by ClosestToEndCell(), operator<(), and dt::DiscreteTracker::TryExtendChainOne().

  {
    if(!fAllHitsDirty) return fAllHits;
    fAllHitsDirty = false;

    fAllHits.clear();
    if(fSegs.size() <= 1) return fAllHits;
    if(fNChunks == 0) return fAllHits;

    for(std::list<Chunk>::const_iterator it = fChunks.begin(); it != fChunks.end(); ++it){
      art::PtrVector<rb::CellHit> chunkHits = it->AllHits();

      // Unless it's the type of chunk you have to do by dead-reckoning the
      // track.
      if(it->IsShowerChunk() ||
         (it == fChunks.begin() && !FirstSeg().left) ||
         (it->Plane() == LastChunk().Plane() && LastSeg().left)){

        chunkHits = it->HitsOnLine(MAvg(), CAvg());
      }

      for(unsigned int m = 0; m < chunkHits.size(); ++m)
        fAllHits.push_back(chunkHits[m]);
    } // end for it

    return fAllHits;
  }

double dt::Cand::CAvg ( ) const

inlineprotected

Definition at line 113 of file Cand.h.

Referenced by AllHits(), ClosestToEndCell(), and EstimateStraightLine().

{return (fAllCMin+fAllCMax)/2;}

double dt::Cand::ClosestToEndCell ( bool  left ) const

protected

Z position.

Definition at line 469 of file Cand.cxx.

References AllHits(), CAvg(), geo::PlaneGeo::Cell(), geo::ClosestApproach(), dir, Dot(), fView, geom(), geo::CellGeo::GetCenter(), CLHEP::L, MAvg(), getGoodRuns4SAM::n, geo::GeometryBase::Plane(), art::PtrVector< T >::size(), and febshutoff_auto::start.

Referenced by EstimateStraightLine().

  {
    double bestL = left ? +1e10 : -1e10;
    double bestZ = -1e10;

    art::ServiceHandle<geo::Geometry> geom;

    const art::PtrVector<rb::CellHit> allhits = AllHits();
    for(unsigned int n = 0; n < allhits.size(); ++n){
      const geo::CellGeo* geocell = geom->Plane(allhits[n]->Plane())->Cell(allhits[n]->Cell());
      double xyz[3];
      geocell->GetCenter(xyz);
      // y-view by convention
      xyz[1] = xyz[fView];
      xyz[0] = 0;

      const TVector3 orig(0, CAvg(), 0);
      const TVector3 dir(0, MAvg(), 1);

      TVector3 start;
      geo::ClosestApproach(TVector3(xyz), orig, dir, start);

      // Distance along the line
      const double L = (start-orig).Dot(dir);

      if((left && L < bestL) ||
         (!left && L > bestL)){
        bestL = L;
        bestZ = start.Z();
      }
    } // end for n

    // TODO
    //    assert(bestZ > -1e10);
    return bestZ;
  }

double dt::Cand::EstimateGradient ( ) const

inline

Definition at line 38 of file Cand.h.

{return MAvg();}

void dt::Cand::EstimateStraightLine	(	double &	z1,
		double &	y1,
		double &	z2,
		double &	y2
	)		const

Definition at line 284 of file Cand.cxx.

References a, ana::assert(), b, CAvg(), ClosestToEndCell(), FirstChunk(), fSegs, geom(), geo::kPLANE_NOT_FOUND, LastChunk(), MAvg(), and dt::Chunk::Plane().

Referenced by ToTrack().

  {
    assert(fSegs.size() > 1);

    art::ServiceHandle<geo::Geometry> geom;

    // Best guess is starting halfway to the previous plane and ending halfway
    // to the next.
    const int firstPlane = FirstChunk().Plane();
    const int prevPlane = fSegs.front().left ? geom->NextPlaneInView(firstPlane, -1) : firstPlane;

    const int lastPlane = LastChunk().Plane();
    const int nextPlane = fSegs.back().left ? lastPlane : geom->NextPlaneInView(lastPlane, +1);

    if(prevPlane != geo::kPLANE_NOT_FOUND){
      double a[3], b[3];
      geom->Plane(prevPlane)->Cell(0)->GetCenter(a);
      geom->Plane(firstPlane)->Cell(0)->GetCenter(b);
      z1 = (a[2]+b[2])/2;
    }
    else{
      z1 = fSegs.front().zL;
    }

    if(nextPlane != geo::kPLANE_NOT_FOUND){
      double a[3], b[3];
      geom->Plane(lastPlane)->Cell(0)->GetCenter(a);
      geom->Plane(nextPlane)->Cell(0)->GetCenter(b);
      z2 = (a[2]+b[2])/2;
    }
    else{
      z2 = fSegs.back().zR;
    }

    // Except if the first or last chunk is partial, in which case our best
    // guess is nearest the centre of the first or last cell.
    if(!fSegs.front().left){
      const double newz1 = ClosestToEndCell(true);
      if(newz1 < fSegs.front().zL) z1 = newz1;
    } // end if


    if(fSegs.back().left){
      const double newz2 = ClosestToEndCell(false);
      if(newz2 > fSegs.back().zR) z2 = newz2;
    }

    const double cavg = CAvg();
    const double mavg = MAvg();

    y1 = cavg+mavg*z1;
    y2 = cavg+mavg*z2;

    assert(z2 >= z1);
  }

const Chunk& dt::Cand::ExtremalChunk ( Direction  dir ) const

inline

Definition at line 46 of file Cand.h.

References dt::kUpstream.

Referenced by dt::DiscreteTracker::TryExtendCand().

    {
      if(dir == kUpstream) return FirstChunk();
      return LastChunk();
    }

unsigned int dt::Cand::ExtremalPlane ( Direction  dir ) const

inline

Definition at line 68 of file Cand.h.

References dt::kUpstream.

Referenced by dt::Chain::ExtremalPlane(), dt::DiscreteTracker::PossibleNextSegs(), and dt::DiscreteTracker::SpliceChains().

    {
      if(dir == kUpstream) return FirstPlane();
      return LastPlane();
    }

const Segment& dt::Cand::ExtremalSeg ( Direction  dir ) const

inline

Definition at line 56 of file Cand.h.

References dt::kUpstream.

Referenced by TryAddSeg().

    {
      if(dir == kUpstream) return FirstSeg();
      return LastSeg();
    }

bool dt::Cand::FindChunk	(	int	plane,
		Chunk &	chunk
	)		const

Definition at line 575 of file Cand.cxx.

References fChunks, it, and NDAPDHVSetting::plane.

  {
    for(std::list<Chunk>::const_iterator it = fChunks.begin(); it != fChunks.end(); ++it){
      if(it->Plane() == plane){
        chunk = *it;
        return true;
      }
    }
    return false;
  }

const Chunk & dt::Cand::FirstChunk

(

)

const

Definition at line 353 of file Cand.cxx.

References fChunks.

Referenced by EstimateStraightLine(), dt::Chain::FirstChunk(), dt::Chain::FirstPlane(), operator<(), dt::DiscreteTracker::PossibleNextSegs(), and dt::Chain::ToTrack().

  {
    return fChunks.front();
  }

unsigned int dt::Cand::FirstPlane ( ) const

inline

Definition at line 66 of file Cand.h.

References dt::Segment::plane.

Referenced by dt::DiscreteTracker::PossibleNextSegs().

{return FirstSeg().plane;}

const Segment & dt::Cand::FirstSeg

(

)

const

Definition at line 365 of file Cand.cxx.

References fSegs.

Referenced by AllHits(), dt::Chain::FirstSeg(), IsExtremalChunkComplete(), dt::DiscreteTracker::PossibleNextSegs(), and ShortenOne().

  {
    return fSegs.front();
  }

bool dt::Cand::IsAllShower

(

)

const

Definition at line 415 of file Cand.cxx.

References fChunks, and it.

Referenced by dt::DiscreteTracker::TryExtendChainOne().

  {
    for(std::list<Chunk>::const_iterator it = fChunks.begin(); it != fChunks.end(); ++it){
      if(!it->IsShowerChunk()) return false;
    }
    return true;
  }

bool dt::Cand::IsExtremalChunkComplete

(

Direction

dir

)

const

Definition at line 377 of file Cand.cxx.

References FirstSeg(), dt::kUpstream, LastSeg(), and dt::Segment::left.

Referenced by MarkExtremalChunkShower(), and dt::DiscreteTracker::TryExtendCand().

  {
    if(dir == kUpstream) return FirstSeg().left;
    return !LastSeg().left;
  }

const Chunk & dt::Cand::LastChunk

(

)

const

Definition at line 359 of file Cand.cxx.

References fChunks.

Referenced by AllHits(), EstimateStraightLine(), dt::Chain::LastChunk(), dt::Chain::LastPlane(), and dt::DiscreteTracker::PossibleNextSegs().

  {
    return fChunks.back();
  }

unsigned int dt::Cand::LastPlane ( ) const

inline

Definition at line 67 of file Cand.h.

References dt::Segment::plane.

Referenced by dt::DiscreteTracker::PossibleNextSegs().

{return LastSeg().plane;}

const Segment & dt::Cand::LastSeg

(

)

const

Definition at line 371 of file Cand.cxx.

References fSegs.

Referenced by AllHits(), IsExtremalChunkComplete(), dt::Chain::LastSeg(), dt::DiscreteTracker::PossibleNextSegs(), and ShortenOne().

  {
    return fSegs.back();
  }

void dt::Cand::MarkExtremalChunkShower

(

Direction

dir

)

Definition at line 384 of file Cand.cxx.

References ana::assert(), fChunks, IsExtremalChunkComplete(), dt::kDownstream, dt::kUpstream, PopFirstSeg(), PopLastSeg(), and TryAddSeg().

Referenced by dt::DiscreteTracker::TryExtendCand().

  {
    const bool complete = IsExtremalChunkComplete(dir);

    if(dir == kUpstream){
      fChunks.begin()->SetShowerChunk();
      if(complete) PopFirstSeg();
      PopFirstSeg();
      const std::pair<Segment, Segment> segs = fChunks.begin()->GetSegs();
      bool ok = TryAddSeg(segs.second, kUpstream);
      assert(ok);
      if(complete){
        ok = TryAddSeg(segs.first, kUpstream);
        assert(ok);
      }
    }
    else{
      fChunks.rbegin()->SetShowerChunk();
      if(complete) PopLastSeg();
      PopLastSeg();
      const std::pair<Segment, Segment> segs = fChunks.rbegin()->GetSegs();
      bool ok = TryAddSeg(segs.first, kDownstream);
      assert(ok);
      if(complete){
        ok = TryAddSeg(segs.second, kDownstream);
        assert(ok);
      }
    }
  }

double dt::Cand::MAvg ( ) const

inlineprotected

Definition at line 112 of file Cand.h.

Referenced by AllHits(), ClosestToEndCell(), and EstimateStraightLine().

{return (fAllMMin+fAllMMax)/2;}

double dt::Cand::MaxGradient ( ) const

inline

Definition at line 37 of file Cand.h.

Referenced by dt::DiscreteTracker::DotScore().

{return fAllMMax;}

Cand dt::Cand::MaybeFlip

(

bool &

ok

)

const

Definition at line 547 of file Cand.cxx.

References AddChunk(), make_associated_cosmic_defs::chunk, fChunks, fSegs, fUp, fView, dt::Chunk::GetSegs(), it, dt::kDownstream, runNovaSAM::ret, dt::Chunk::SetUp(), and TryAddSeg().

Referenced by dt::DiscreteTracker::DotScore(), and dt::DiscreteTracker::TryExtendCand().

  {
    Cand ret(fView, !fUp);

    for(std::list<Chunk>::const_iterator it = fChunks.begin(); it != fChunks.end(); ++it){
      Chunk chunk = *it;
      chunk.SetUp(!fUp);
      ret.AddChunk(chunk, kDownstream);

      const std::pair<Segment, Segment> segs = chunk.GetSegs();

      // Add first seg unless it's the very first and we don't have it
      if(it != fChunks.begin() || fSegs.front().left){
        ok = ret.TryAddSeg(segs.first, kDownstream);
        if(!ok) return ret;
      }

      // Add second seg unless it's the last and we don't have it
      if(ret.fSegs.size() < fSegs.size()){
        ok = ret.TryAddSeg(segs.second, kDownstream);
        if(!ok) return ret;
      }
    }

    return ret;
  }

double dt::Cand::MinGradient ( ) const

inline

Definition at line 36 of file Cand.h.

Referenced by dt::DiscreteTracker::DotScore().

{return fAllMMin;}

void dt::Cand::MinMaxLines ( const Segment &  segi, const Segment &  segj, double &  mmax, double &  mmin, double &  cmax, double &  cmin  ) const

protected

Helper for TryAddSeg.

Definition at line 127 of file Cand.cxx.

References cmax, dz, dt::Segment::GetSubSeg(), dt::kDownstream, dt::kUpstream, and dt::Segment::zL.

Referenced by PopSegHelper(), and TryAddSeg().

  {
    const double dz = segj.zL-segi.zL;

    if(dz < 0){
      MinMaxLines(segj, segi, mmax, mmin, cmax, cmin);
      return;
    }

    mmax = +1e10;
    mmin = -1e10;
    cmax = +1e10;
    cmin = -1e10;

    MinMaxLines(segi.GetSubSeg(kUpstream),   segj.GetSubSeg(kUpstream),   mmax, mmin, cmax, cmin);
    MinMaxLines(segi.GetSubSeg(kUpstream),   segj.GetSubSeg(kDownstream), mmax, mmin, cmax, cmin);
    MinMaxLines(segi.GetSubSeg(kDownstream), segj.GetSubSeg(kUpstream),   mmax, mmin, cmax, cmin);
    MinMaxLines(segi.GetSubSeg(kDownstream), segj.GetSubSeg(kDownstream), mmax, mmin, cmax, cmin);
  }

void dt::Cand::MinMaxLines ( const SubSeg &  segi, const SubSeg &  segj, double &  mmax, double &  mmin, double &  cmax, double &  cmin  ) const

protected

Definition at line 110 of file Cand.cxx.

References ana::assert(), dz, std::max(), std::min(), dt::SubSeg::y0, dt::SubSeg::y1, and dt::SubSeg::z.

  {
    const double dz = segj.z-segi.z;

    // Got sorted at some earlier stage
    assert(dz > 0);

    mmax = std::min(mmax, (segj.y1-segi.y0)/dz);
    mmin = std::max(mmin, (segj.y0-segi.y1)/dz);

    cmax = std::min(cmax, segi.y1-segi.z*(segj.y0-segi.y1)/dz);
    cmin = std::max(cmin, segi.y0-segi.z*(segj.y1-segi.y0)/dz);
  }

unsigned int dt::Cand::NChunks ( ) const

inline

Definition at line 41 of file Cand.h.

Referenced by dt::Chain::Add(), dt::Chain::AddFront(), and dt::DiscreteTracker::TryExtendChainOne().

{return fNChunks;}

unsigned int dt::Cand::NDeadChunks ( ) const

inline

Definition at line 42 of file Cand.h.

{return fNDeadChunks;}

int dt::Cand::NHitPlanes

(

)

const

Definition at line 342 of file Cand.cxx.

References fChunks, it, and runNovaSAM::ret.

Referenced by operator<().

  {
    int ret = 0;
    for(std::list<Chunk>::const_iterator it = fChunks.begin(); it != fChunks.end(); ++it){
      if(!it->AllDead()) ++ret;
    }

    return ret;
  }

int dt::Cand::NSegs ( ) const

inline

Definition at line 85 of file Cand.h.

References cmax, febshutoff_auto::end, art::left(), operator==(), and NDAPDHVSetting::plane.

Referenced by dt::Chain::Add(), dt::Chain::AddFront(), dt::DiscreteTracker::BestSeed(), dt::DiscreteTracker::DotScore(), dt::DiscreteTracker::RecoDiscrete(), dt::DiscreteTracker::TryExtendCand(), dt::DiscreteTracker::TryExtendCandOne(), and dt::DiscreteTracker::TryExtendChainOne().

{return fSegs.size();}

bool dt::Cand::operator<

(

const Cand &

rhs

)

const

Definition at line 80 of file Cand.cxx.

References AllHits(), FirstChunk(), fNDeadChunks, fSegs, NHitPlanes(), dt::Chunk::Plane(), and art::PtrVector< T >::size().

  {
    // This is sufficient to sort them, but can't be used for a map or set
    // Possibly shouldn't include it as an operator then...

    if(NHitPlanes() < rhs.NHitPlanes()) return true;
    if(NHitPlanes() > rhs.NHitPlanes()) return false;

    if(fSegs.size() < rhs.fSegs.size()) return true;
    if(fSegs.size() > rhs.fSegs.size()) return false;

    // Having more dead is a _bad_ thing. Select the ones without
    // preferentially
    if(fNDeadChunks > rhs.fNDeadChunks) return true;
    if(fNDeadChunks < rhs.fNDeadChunks) return false;

    //    if(fChunks.size() < rhs.fChunks.size()) return true;
    //    if(fChunks.size() > rhs.fChunks.size()) return false;

    // Even if these are only destined to be singleton chunks, need to give the
    // biggest ones back first because we'll stop looking for new chains when
    // we see small ones.
    if(AllHits().size() < rhs.AllHits().size()) return true;
    if(AllHits().size() > rhs.AllHits().size()) return false;

    // Arbitrary, but removes dependence on order FindCands emits things
    return FirstChunk().Plane() < rhs.FirstChunk().Plane();
  }

bool dt::Cand::operator==

(

const Cand &

rhs

)

const

Definition at line 587 of file Cand.cxx.

References fSegs, fUp, and fView.

  {
    if(fView != rhs.fView) return false;
    if(fUp != rhs.fUp) return false;

    return fSegs == rhs.fSegs;
  }

void dt::Cand::PopFirstChunk

(

)

Definition at line 53 of file Cand.cxx.

References fAllHitsDirty, fChunks, fNChunks, and fNDeadChunks.

Referenced by ShortenOne().

  {

    if(fChunks.front().HasHits())
      --fNChunks;
    else
      --fNDeadChunks;

    fChunks.pop_front();

    fAllHitsDirty = true;
  }

void dt::Cand::PopFirstSeg

(

)

Definition at line 212 of file Cand.cxx.

References ana::assert(), fSegs, dt::kUpstream, and PopSegHelper().

Referenced by MarkExtremalChunkShower(), and ShortenOne().

  {
    assert(fSegs.size() > 1);

    const Segment segi = fSegs.front();
    fSegs.pop_front();

    PopSegHelper(segi, kUpstream);
  }

void dt::Cand::PopLastChunk

(

)

Definition at line 67 of file Cand.cxx.

References fAllHitsDirty, fChunks, fNChunks, and fNDeadChunks.

Referenced by ShortenOne().

  {
    if(fChunks.back().HasHits())
      --fNChunks;
    else
      --fNDeadChunks;

    fChunks.pop_back();

    fAllHitsDirty = true;
  }

void dt::Cand::PopLastSeg

(

)

Definition at line 223 of file Cand.cxx.

References ana::assert(), fSegs, dt::kDownstream, and PopSegHelper().

Referenced by MarkExtremalChunkShower(), and ShortenOne().

  {
    assert(fSegs.size() > 1);

    const Segment segi = fSegs.back();
    fSegs.pop_back();

    PopSegHelper(segi, kDownstream);
  }

void dt::Cand::PopSegHelper ( const Segment &  segi, Direction  end  )

protected

Definition at line 234 of file Cand.cxx.

References ana::assert(), cmax, e, fAllCMax, fAllCMin, fAllMMax, fAllMMin, fSegs, it, dt::kDownstream, MinMaxLines(), and TryAddSeg().

Referenced by PopFirstSeg(), and PopLastSeg().

  {
    if(fSegs.size() == 1){
      fAllMMax = +1e10;
      fAllMMin = -1e10;
      fAllCMax = +1e10;
      fAllCMin = -1e10;
      return;
    }

    // Work out if this seg was responsible for any of the strongest
    // constraints.
    bool needRecalc = false;
    for(std::list<Segment>::iterator it = fSegs.begin(); it != fSegs.end(); ++it){
      const Segment& segj = *it;

      double mmax, mmin, cmax, cmin;
      MinMaxLines((end == kDownstream) ? segj : segi,
                  (end == kDownstream) ? segi : segj,
                  mmax, mmin, cmax, cmin);

      if(mmax-1e-6 < fAllMMax ||
         mmin+1e-6 > fAllMMin ||
         cmax-1e-6 < fAllCMax ||
         cmin+1e-6 > fAllCMin){
        needRecalc = true;
        break;
      }
    }

    if(!needRecalc) return;

    // If this seg was important, need to recalculate the whole lot to find the
    // 2nd most stringent. To avoid this we'd have to store more information in
    // the object.
    std::list<Segment> segs = fSegs;
    fSegs.clear();

    fAllMMax = +1e10;
    fAllMMin = -1e10;
    fAllCMax = +1e10;
    fAllCMin = -1e10;

    for(std::list<Segment>::iterator it = segs.begin(); it != segs.end(); ++it){
      const bool ok = TryAddSeg(*it, kDownstream);
      assert(ok);
    }
  }

void dt::Cand::ShortenOne

(

Direction

dir

)

Definition at line 533 of file Cand.cxx.

References FirstSeg(), dt::kDownstream, LastSeg(), art::left(), PopFirstChunk(), PopFirstSeg(), PopLastChunk(), and PopLastSeg().

Referenced by dt::DiscreteTracker::TryExtendChainOne().

  {
    if(dir == kDownstream){
      if(!FirstSeg().left) PopFirstChunk();
      PopFirstSeg();
    }
    else{
      if(LastSeg().left) PopLastChunk();
      PopLastSeg();
    }
  }

rb::Track dt::Cand::ToTrack

(

)

const

Definition at line 453 of file Cand.cxx.

References rb::Cluster::Add(), rb::Track::AppendTrajectoryPoint(), EstimateStraightLine(), fChunks, fView, it, runNovaSAM::ret, y1, and submit_syst::y2.

Referenced by dt::DiscreteTracker::RecoOneTrack().

  {
    double z1, y1, z2, y2;
    EstimateStraightLine(z1, y1, z2, y2);
    rb::Track ret(art::PtrVector<rb::CellHit>(),
                  fView, y1, z1, y2-y1, z2-z1);
    ret.AppendTrajectoryPoint(y2, z2);
    for(std::list<Chunk>::const_iterator it = fChunks.begin(); it != fChunks.end(); ++it){
      ret.Add(it->AllHits());
    }
    // TODO: this can happen sometimes, figure out when and why
    //    assert(ret.NCell() > 0);
    return ret;
  }

void dt::Cand::TrimBack

(

)

Definition at line 520 of file Cand.cxx.

References fAllHitsDirty, fChunks, fSegs, and NDAPDHVSetting::plane.

  {
    fAllHitsDirty = true;

    while(!fChunks.empty()){
      if(!fChunks.back().AllDead()) return;
      const int plane = fChunks.back().Plane();
      fChunks.pop_back();
      while(fSegs.back().plane == plane) fSegs.pop_back();
    }
  }

void dt::Cand::TrimFront

(

)

Definition at line 507 of file Cand.cxx.

References fAllHitsDirty, fChunks, fSegs, and NDAPDHVSetting::plane.

  {
    fAllHitsDirty = true;

    while(!fChunks.empty()){
      if(!fChunks.front().AllDead()) return;
      const int plane = fChunks.front().Plane();
      fChunks.pop_front();
      while(fSegs.front().plane == plane) fSegs.pop_front();
    }
  }

bool dt::Cand::TryAddSeg	(	const Segment &	seg,
		Direction	dir,
		bool	check = true
	)

Appends seg to fSegs and updates internal state reflecting limits on the possible straight lines. If the new seg is impossible to accomodate, returns false and guarantees not to change any state.

Definition at line 150 of file Cand.cxx.

References ana::assert(), cmax, ExtremalSeg(), fAllCMax, fAllCMin, fAllHitsDirty, fAllMMax, fAllMMin, fSegs, fUp, it, dt::kDownstream, dt::Segment::left, std::max(), std::min(), and MinMaxLines().

Referenced by dt::DiscreteTracker::BestSeed(), MarkExtremalChunkShower(), MaybeFlip(), PopSegHelper(), TryAddSegOutOfOrder(), and dt::DiscreteTracker::TryExtendCandOne().

  {
    if(check){
      // Must alternate sides
      assert(fSegs.empty() || seg.left != ExtremalSeg(dir).left);
    }

    double newAllMMax = fAllMMax;
    double newAllMMin = fAllMMin;
    double newAllCMax = fAllCMax;
    double newAllCMin = fAllCMin;

    for(std::list<Segment>::iterator it = fSegs.begin(); it != fSegs.end(); ++it){
      const Segment& segi = *it;
      // In principle would have to loop over all j > i. But this happens every
      // time we add a new seg, so only the last one is novel.
      const Segment& segj = seg;

      double mmax, mmin, cmax, cmin;
      MinMaxLines(segi, segj, mmax, mmin, cmax, cmin);
      newAllMMax = std::min(mmax, newAllMMax);
      newAllMMin = std::max(mmin, newAllMMin);
      newAllCMax = std::min(cmax, newAllCMax);
      newAllCMin = std::max(cmin, newAllCMin);

      if(newAllMMax <= newAllMMin ||
         newAllCMax <= newAllCMin) return false;
    } // end for it

    // TODO: I'm worried about the interaction of this with imperfect
    // geometry/staggering, but it, or something like it, is necessary to
    // prevent cands with the obviously "wrong" sense through one-cell chunks
    if((fUp && newAllMMax < 0) || (!fUp && newAllMMin > 0)) return false;

    // Everything checks out, finalize the addition

    if(dir == kDownstream)
      fSegs.push_back(seg);
    else
      fSegs.push_front(seg);

    fAllHitsDirty = true;

    fAllMMax = newAllMMax;
    fAllMMin = newAllMMin;
    fAllCMax = newAllCMax;
    fAllCMin = newAllCMin;

    return true;
  }

bool dt::Cand::TryAddSegOutOfOrder

(

const Segment &

seg

)

Definition at line 202 of file Cand.cxx.

References fSegs, dt::kDownstream, and TryAddSeg().

  {
    if(TryAddSeg(seg, kDownstream, false)){
      fSegs.sort();
      return true;
    }
    return false;
  }

bool dt::Cand::Up ( ) const

inline

Definition at line 61 of file Cand.h.

Referenced by dt::DiscreteTracker::BestSeed(), and dt::DiscreteTracker::PossibleNextSegs().

{return fUp;}

geo::View_t dt::Cand::View ( ) const

inline

Returns

Number of segs in common, or -1 if requirements aren't met

Definition at line 40 of file Cand.h.

Referenced by dt::Chain::ToTrack().

{return fView;}

Member Data Documentation

double dt::Cand::fAllCMax

protected

Definition at line 119 of file Cand.h.

Referenced by PopSegHelper(), and TryAddSeg().

double dt::Cand::fAllCMin

protected

Definition at line 119 of file Cand.h.

Referenced by PopSegHelper(), and TryAddSeg().

art::PtrVector<rb::CellHit> dt::Cand::fAllHits

mutableprotected

Always access via AllHits.

Definition at line 128 of file Cand.h.

Referenced by AllHits().

bool dt::Cand::fAllHitsDirty

mutableprotected

Definition at line 126 of file Cand.h.

Referenced by AddChunk(), AllHits(), PopFirstChunk(), PopLastChunk(), TrimBack(), TrimFront(), and TryAddSeg().

double dt::Cand::fAllMMax

protected

Definition at line 119 of file Cand.h.

Referenced by PopSegHelper(), and TryAddSeg().

double dt::Cand::fAllMMin

protected

Definition at line 119 of file Cand.h.

Referenced by PopSegHelper(), and TryAddSeg().

std::list<Chunk> dt::Cand::fChunks

protected

Definition at line 124 of file Cand.h.

Referenced by AddChunk(), AllHits(), FindChunk(), FirstChunk(), IsAllShower(), LastChunk(), MarkExtremalChunkShower(), MaybeFlip(), NHitPlanes(), PopFirstChunk(), PopLastChunk(), ToTrack(), TrimBack(), and TrimFront().

int dt::Cand::fNChunks

protected

Definition at line 121 of file Cand.h.

Referenced by AddChunk(), AllHits(), PopFirstChunk(), and PopLastChunk().

int dt::Cand::fNDeadChunks

protected

Definition at line 121 of file Cand.h.

Referenced by AddChunk(), operator<(), PopFirstChunk(), and PopLastChunk().

std::list<Segment> dt::Cand::fSegs

protected

Definition at line 123 of file Cand.h.

Referenced by AllHits(), EstimateStraightLine(), FirstSeg(), LastSeg(), MaybeFlip(), operator<(), operator==(), PopFirstSeg(), PopLastSeg(), PopSegHelper(), TrimBack(), TrimFront(), TryAddSeg(), and TryAddSegOutOfOrder().

bool dt::Cand::fUp

protected

Definition at line 117 of file Cand.h.

Referenced by AddChunk(), MaybeFlip(), operator==(), and TryAddSeg().

geo::View_t dt::Cand::fView

protected

Definition at line 115 of file Cand.h.

Referenced by ClosestToEndCell(), MaybeFlip(), operator==(), and ToTrack().

---

The documentation for this class was generated from the following files:

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-12-03/DiscreteTracker/Cand.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-12-03/DiscreteTracker/Cand.cxx