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) const;

  virtual bool operator<(const DTSegmentCand& seg) const;

  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