DTSegmentCand.h

Go to the documentation of this file.

#ifndef DTSegment_DTSegmentCand_h
#define DTSegment_DTSegmentCand_h
 
/* Base Class Headers */
 
/* Collaborating Class Declarations */
#include "RecoLocalMuon/DTSegment/src/DTHitPairForFit.h"
 
/* C++ Headers */
#include <vector>
#include <set>
#include <iostream>
 
/* ====================================================================== */
 
/* Class DTSegmentCand Interface */
 
class DTSLRecSegment2D;
class DTChamberRecSegment2D;
class DTChamber;
class DTSuperLayer;
 
class DTSegmentCand {
public:
  struct AssPointLessZ;
  typedef std::pair<std::shared_ptr<DTHitPairForFit>, DTEnums::DTCellSide> AssPoint;
  typedef std::set<AssPoint, AssPointLessZ> AssPointCont;
 
  DTSegmentCand(AssPointCont& hits, const DTSuperLayer* sl);
 
  DTSegmentCand(const AssPointCont& hits,
                LocalPoint& position,
                LocalVector& direction,
                double chi2,
                const AlgebraicSymMatrix& covMat,
                const DTSuperLayer* sl);
 
  virtual ~DTSegmentCand();
 
  /* Operations */
  virtual bool good() const;
 
  virtual bool hitsShareLayer() const;
 
  virtual unsigned int nHits() const { return theHits.size(); }
 
  virtual double chi2() const { return theChi2; }
 
  virtual double chi2ndof() const { return theChi2 / (nHits() - 2.); }
 
  virtual double t0() const { return thet0; }
 
  virtual bool operator==(const DTSegmentCand& seg);
 
  virtual bool operator<(const DTSegmentCand& seg);
 
  const DTSuperLayer* superLayer() const { return theSL; }
 
  // in SL frame
  virtual LocalPoint position() const { return thePosition; }
 
  // in SL frame
  virtual LocalVector direction() const { return theDirection; }
 
  virtual AlgebraicSymMatrix covMatrix() const { return theCovMatrix; }
 
  virtual unsigned int NDOF() const { return nHits() - 2; }
 
  virtual void setPosition(LocalPoint& pos) { thePosition = pos; }
 
  virtual void setDirection(LocalVector& dir) { theDirection = dir; }
 
  virtual void add(AssPoint newHit);
  virtual void add(std::shared_ptr<DTHitPairForFit> hit, DTEnums::DTCellSide code);
 
  virtual void removeHit(AssPoint hit);
 
  virtual void setChi2(double& chi2) { theChi2 = chi2; }
 
  virtual void sett0(double& t0) { thet0 = t0; }
 
  virtual int nSharedHitPairs(const DTSegmentCand& seg) const;
 
  virtual AssPointCont conflictingHitPairs(const DTSegmentCand& seg) const;
 
  virtual void setCovMatrix(AlgebraicSymMatrix& cov) { theCovMatrix = cov; }
 
  virtual int nLayers() const;
 
  virtual const AssPointCont& hits() const { return theHits; }
 
  //  DTSLRecSegment2D* convert() const;
  operator DTSLRecSegment2D*() const;
 
  operator DTChamberRecSegment2D*() const;
 
  struct AssPointLessZ {
  public:
    bool operator()(const AssPoint& pt1, const AssPoint& pt2) const;
  };
 
private:
  const DTSuperLayer* theSL;  // the SL
  LocalPoint thePosition;     // in SL frame
  LocalVector theDirection;   // in SL frame
  double theChi2;             // chi2 of the fit
  double thet0;               // the t0 offset
 
  AlgebraicSymMatrix theCovMatrix;  // the covariance matrix
 
  AssPointCont theHits;  // the used hits
 
protected:
  static const double chi2max;         // to be tuned!!
  static const unsigned int nHitsMin;  // to be tuned!!
};
 
std::ostream& operator<<(std::ostream& out, const DTSegmentCand& seg);
std::ostream& operator<<(std::ostream& out, const DTSegmentCand::AssPoint& hit);
#endif  // DTSegment_DTSegmentCand_h