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 std::binary_function<const AssPoint&, const AssPoint&, bool> {
        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