Cand.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    Cand.h
// \version $Id: Cand.h,v 1.21 2012-10-31 00:05:29 bckhouse Exp $
// \author  Christopher Backhouse - bckhouse@caltech.edu
////////////////////////////////////////////////////////////////////////

#ifndef DTCAND_H
#define DTCAND_H

#include "GeometryObjects/PlaneGeo.h"

#include <vector>

#include "DiscreteTracker/Chunk.h"
#include "DiscreteTracker/Types.h"

#include "RecoBase/Track.h"

namespace rb{class Cluster;}

namespace dt
{
  /// \brief Calculation and representation of a straight line passing through
  /// several "segment" windows.
  class Cand
  {
  public:
    Cand(geo::View_t view, bool up);
    /// Simply store the chunk in the list. Need to call \ref AddSeg too
    void AddChunk(const Chunk& chunk, Direction dir);
    void PopFirstChunk();
    void PopLastChunk();
    bool operator<(const Cand& rhs) const;
    void EstimateStraightLine(double& z1, double& y1,
                              double& z2, double& y2) const;
    double MinGradient() const {return fAllMMin;}
    double MaxGradient() const {return fAllMMax;}
    double EstimateGradient() const {return MAvg();}
    /// \return Number of segs in common, or -1 if requirements aren't met
    geo::View_t View() const {return fView;}
    unsigned int NChunks() const {return fNChunks;}
    unsigned int NDeadChunks() const {return fNDeadChunks;}
    int NHitPlanes() const;
    const Chunk& FirstChunk() const;
    const Chunk& LastChunk() const;
    const Chunk& ExtremalChunk(Direction dir) const
    {
      if(dir == kUpstream) return FirstChunk();
      return LastChunk();
    }
    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
    {
      if(dir == kUpstream) return FirstSeg();
      return LastSeg();
    }
    bool Up() const {return fUp;}
    art::PtrVector<rb::CellHit> AllHits() const;
    rb::Track ToTrack() const; // For debugging
    /// Sorted in plane order
    std::list<Chunk> AllChunks() const {return fChunks;}
    unsigned int FirstPlane() const {return FirstSeg().plane;}
    unsigned int LastPlane() const {return LastSeg().plane;}
    unsigned int ExtremalPlane(Direction dir) const
    {
      if(dir == kUpstream) return FirstPlane();
      return LastPlane();
    }

    /// \brief Appends \a seg to \ref 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.
    bool TryAddSeg(const Segment& seg, Direction dir, bool check = true);

    bool TryAddSegOutOfOrder(const Segment& seg);

    void PopFirstSeg();
    void PopLastSeg();

    int NSegs() const {return fSegs.size();}

    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:
    /// Helper for \ref TryAddSeg
    void MinMaxLines(const Segment& segi, const Segment& segj,
                     double& mmax, double& mmin,
                     double& cmax, double& cmin) const;

    void MinMaxLines(const SubSeg& segi, const SubSeg& segj,
                     double& mmax, double& mmin,
                     double& cmax, double& cmin) const;

    void PopSegHelper(const Segment& segi, Direction end);

    /// Z position
    double ClosestToEndCell(bool left) const;

    double MAvg() const {return (fAllMMin+fAllMMax)/2;}
    double CAvg() const {return (fAllCMin+fAllCMax)/2;}

    geo::View_t fView;

    bool fUp;

    double fAllMMax, fAllMMin, fAllCMax, fAllCMin;

    int fNChunks, fNDeadChunks;

    std::list<Segment> fSegs;
    std::list<Chunk> fChunks;

    mutable bool fAllHitsDirty;
    /// Always access via \ref AllHits
    mutable art::PtrVector<rb::CellHit> fAllHits;
  };
} // namespace

#endif