---

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<DTHitPairForFit*, DTEnums::DTCellSide> AssPoint;
    typedef std::set<AssPoint, AssPointLessZ> AssPointCont;

    DTSegmentCand(AssPointCont& hits,
                  const DTSuperLayer* sl) ;

    DTSegmentCand(AssPointCont hits,
                  LocalPoint& position,
                  LocalVector& direction,
                  double chi2,
                  AlgebraicSymMatrix covMat,
                  const DTSuperLayer* sl);

    ~DTSegmentCand() ;

/* Operations */ 
    bool good() const ;

    unsigned int nHits() const { return theHits.size(); }

    double chi2() const {return theChi2; }

    double chi2ndof() const {return theChi2/(nHits()-2.); }

    bool operator==(const DTSegmentCand& seg);

    bool operator<(const DTSegmentCand& seg);

    //  /// the super layer on which relies 
    // const DTSuperLayer* superLayer() const {return theSL;}

    // in SL frame
    LocalPoint  position() const { return thePosition; }

    // in SL frame
    LocalVector direction() const { return theDirection;}

    AlgebraicSymMatrix covMatrix() const {return theCovMatrix; }

    unsigned int NDOF() const { return nHits()-2; }

    void setPosition(LocalPoint& pos) { thePosition=pos; }

    void setDirection(LocalVector& dir) { theDirection = dir ; }

    void add(DTHitPairForFit* hit, DTEnums::DTCellSide code) ;

    void removeHit(AssPoint hit) ;

    void setChi2(double& chi2) { theChi2 = chi2 ;}

    int nSharedHitPairs(const DTSegmentCand& seg) const;

    AssPointCont conflictingHitPairs(const DTSegmentCand& seg) const;

    void setCovMatrix(AlgebraicSymMatrix& cov) { theCovMatrix = cov; }

    int nLayers() 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 ; 
      };
  protected:

  private:
    const DTSuperLayer* theSL; // the SL
    LocalPoint  thePosition;  // in SL frame
    LocalVector theDirection; // in SL frame
    double theChi2;           // chi2 of the fit

    AlgebraicSymMatrix theCovMatrix; // the covariance matrix


    AssPointCont theHits; // the used hits

    static double chi2max; // to be tuned!!
    static 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

---