HoughHit.h

Go to the documentation of this file.

#ifndef HOUGHHIT2_H
#define HOUGHHIT2_H
 
 
#include "MdcRawEvent/MdcDigi.h"
#include "CgemRecEvent/RecCgemCluster.h"
#include "McTruth/MdcMcHit.h"
#include "McTruth/CgemMcHit.h"
#include "CLHEP/Geometry/Point3D.h"
#include "MdcData/MdcHit.h"
 
#include "MdcGeomSvc/MdcGeomSvc.h"
#include "MdcCalibFunSvc/MdcCalibFunSvc.h"
#include "CgemGeomSvc/CgemGeomSvc.h"
#include "CgemCalibFunSvc/CgemCalibFunSvc.h"
#include <vector>
#include "HoughTransAlg/HoughTrack.h"
#include "MdcGeom/MdcDetector.h"
 
class HoughTrack;
 
using namespace Event;
 
class HoughHit
{
  public:
    enum HitType{CGEMHIT = 0, MDCHIT = 1, CGEMMCHIT = 2, MDCMCHIT = 3};
    typedef std::pair<double,double> S_Z;
 
    HoughHit();
    HoughHit(const MdcDigi* mdcDigi, double bunchTime, int hitID);
    HoughHit(const RecCgemCluster* cgemCgemCluster, double bunchTime, int hitID);
    HoughHit(const MdcMcHit* mdcMcHit, double bunchTime, int hitID);
    HoughHit(const CgemMcHit* cgemMcHit, double bunchTime, int hitID);
    HoughHit(const HoughHit& other);
    HoughHit& operator=(const HoughHit& other);
    //~HoughHit();
 
    int                     getHitID() const {return m_hitID;}
    HitType                 getHitType() const {return m_hitType;}
    const                   RecCgemCluster* getCgemCluster() const {return m_cgemCluster;}
    const                   MdcDigi* getDigi() const {return m_mdcDigi;}
    const                   CgemMcHit* getCgemMcHit()const{return m_cgemMcHit;}
    const                   MdcMcHit* getMdcMcHit()const{return m_mdcMcHit;}
    int                     getLayer() const {return m_layer;}
    int                     getWire() const {return m_wire;}
    int                     getFlag() const {return m_flag;}
    double                  getBunchTime() const {return m_bunchTime;}
    double                  getRawTime() const {return m_rawTime;}
    double                  getDepositEnergy() const {return m_depositEnergy;}
    HepPoint3D              getHitPosition() const {return m_hitPosition;}
    HepPoint3D              getWestPoint() const {return m_westPoint;}
    HepPoint3D              getEastPoint() const {return m_eastPoint;}
    double                  getDriftDist() const {return m_driftDist;}
    double                  getResidual() const {return m_residual;}
    vector<int>             getTrkID() const {return m_trkID;}
    vector<HoughTrack*>     getTrkPntVec() {return m_vecTrkPnt;}
    int                     getUse() const {return m_use;}
    //int                     getSLeft() const {return m_sLeft;}
    //int                     getZLeft() const {return m_zLeft;}
    //int                     getSRight() const {return m_sRight;}
    //int                     getZRight() const {return m_zRight;}
    vector<S_Z>             getSZ() const {return m_sz;}
 
    MdcGeomSvc*             getMdcGeomSvc() const {return m_mdcGeomSvc;} 
    MdcCalibFunSvc*         getMdcCalibFunSvc() const {return m_mdcCalibFunSvc;}
    CgemGeomSvc*            getCgemGeomSvc() const {return m_cgemGeomSvc;}
    CgemCalibFunSvc*        getCgemCalibFunSvc() const {return m_cgemCalibFunSvc;}
 
    int                     getHalfCircle(){return m_halfCircle;}
    HoughHit*               getPairHit(){return m_pairHit;}
 
    void                    setHitID(int hitID) {m_hitID = hitID;}
    void                    setHitType(HitType hitType){m_hitType = hitType;}
    void                    setCgemCluster(const RecCgemCluster* cgemCluster){m_cgemCluster = cgemCluster;}
    void                    setDigi(const MdcDigi* mdcDigi){m_mdcDigi = mdcDigi;}
    void                    setCgemMcHit(const CgemMcHit* cgemMcHit){m_cgemMcHit = cgemMcHit;}
    void                    setMdcMcHit(const MdcMcHit* mdcMcHit){m_mdcMcHit = mdcMcHit;}
    void                    setLayer(int layer){m_layer = layer;}
    void                    setWire(int wire){m_wire = wire;}
    void                    setFlag(int flag){m_flag = flag;}
    void                    setUse(int use) {m_use = use;}
    void                    setBunchTime(double bunchTime){m_bunchTime = bunchTime;}
    void                    setRawTime(double rawTime){m_rawTime = rawTime;}
    void                    setDepositEnergy(double depositEnergy){m_depositEnergy = depositEnergy;}
    void                    setHitPosition(HepPoint3D point){m_hitPosition = point;}
    //void                    setWestPoint(HepPoint3D point){m_westPoint = point;}
    //void                    setEastPoint(HepPoint3D point){m_eastPoint = point;}
    void                    setDriftDist(double driftDist){m_driftDist = driftDist;}
    void                    setResidual(double residual) {m_residual = residual;}
    void                    setTrkID(vector<int> trkID) {m_trkID.clear();m_trkID = trkID;}
    //void                    setSLeft(double s) {m_sLeft = s;}
    //void                    setZLeft(double z) {m_zLeft = z;}
    //void                    setSRight(double s) {m_sRight = s;}
    //void                    setZRight(double z) {m_zRight = z;}
    void                    setSZ(vector<S_Z> sz) {m_sz.clear();m_sz = sz;}
    void                    resetSZ() {m_sz.clear();}
 
    static void             setMdcGeomSvc(MdcGeomSvc* mdcGeomSvc) {m_mdcGeomSvc = mdcGeomSvc;}
    static void             setMdcCalibFunSvc(MdcCalibFunSvc* mdcCalibFunSvc) {m_mdcCalibFunSvc = mdcCalibFunSvc;}
    static void             setCgemGeomSvc(CgemGeomSvc* cgemGeomSvc) {m_cgemGeomSvc = cgemGeomSvc;}
    static void             setCgemCalibFunSvc(CgemCalibFunSvc* cgemCalibFunSvc) {m_cgemCalibFunSvc = cgemCalibFunSvc;}
    static void             setMdcDetector(const MdcDetector* mdcDetector) {m_mdcDetector = mdcDetector;}
 
    void                    addTrkID(int trkID) {m_trkID.push_back(trkID);}
    void                    addSZ(S_Z sz) {m_sz.push_back(sz);}
    void                    addTrkPnt(HoughTrack* aHTrk) {m_vecTrkPnt.push_back(aHTrk);}
    void                    rmTrkPnt(HoughTrack* aHTrk)  {vector<HoughTrack*>::iterator result = find(m_vecTrkPnt.begin(), m_vecTrkPnt.end(), aHTrk); if(result!=m_vecTrkPnt.end()) m_vecTrkPnt.erase(result);}
    void                    clearTrkPnt() {m_vecTrkPnt.clear();}
    void                    dropTrkID(int trkID); // remove trk ID and its residual
    //{vector<int>::iterator result = find(m_trkID.begin(),m_trkID.end(),trkID); if(result!=m_trkID.end()) m_trkID.erase(result);}
 
    void  addResid(double res) {m_vecResid.push_back(res);}
    vector<double> getVecResid() {return m_vecResid;}
 
    void                    setPairHit(HoughHit* pairHit){m_pairHit = pairHit;}
    void                    setHalfCircle(int halfCircle){m_halfCircle = halfCircle;}
    void                    addPosition(HepPoint3D position){m_position.push_back(position);}
 
    //void                  buildMap(int x_bin, double x_min, double x_max, int y_bin, double y_min, double y_max, int nPoint, int charge);
    //void                  clearMap();
    void                    print();
    double                  driftTime();
    double                  hitSigma();
    vector<HepPoint3D>&     VHitPosition(HoughTrack* track);      
    double                  residual(HoughTrack* track);
    void                    updateVHit(HoughTrack* track);
    //double                  flightArc(HoughTrack* track);
    //double                  flightLength(HoughTrack* track);
    //double                  dPhi(HoughTrack* track);
    //double                  doca(HoughTrack* track);
    double                  residual(HoughTrack* track, HepPoint3D& positionOntrack, HepPoint3D& positionOnDetector);
    int                     attach2NTrack(){return m_trkID.size();}
    MdcHit*                 getMdcHit(){return m_mdcHit;}
    void                    setMdcHit(MdcHit* mdcHit){m_mdcHit = mdcHit;}
 
  private:
    int                     flag();
    double                  driftDistance();
 
  private:
    unsigned int            m_hitID;
    HitType                 m_hitType;
    const RecCgemCluster*   m_cgemCluster;
    const MdcDigi*          m_mdcDigi;
    const CgemMcHit*        m_cgemMcHit;
    const MdcMcHit*         m_mdcMcHit;
    unsigned                m_layer;
    unsigned                m_wire;
    int                     m_flag;// 0, -1, +1 for wires of DC; 0, 1, 2 for CGEM clusters
    int                     m_use;
    double                  m_bunchTime;
    double                  m_rawTime;
    double                  m_depositEnergy;
    HepPoint3D              m_hitPosition;
    HepPoint3D              m_westPoint;
    HepPoint3D              m_eastPoint;
    double                  m_driftDist;
 
    double                  m_residual;
    vector<int>             m_trkID;
    vector<double>          m_vecResid;
    vector<S_Z>             m_sz;
    vector<HoughTrack*>     m_vecTrkPnt;
    vector<HepPoint3D>      m_position;
 
    int                     m_halfCircle;
    HoughHit*               m_pairHit;
    MdcHit*                 m_mdcHit;
    
    //double                  m_sLeft;
    //double                  m_zLeft;
    //double                  m_sRight;
    //double                  m_zRight;
 
    static MdcGeomSvc*      m_mdcGeomSvc;
    static MdcCalibFunSvc*  m_mdcCalibFunSvc;
    static CgemGeomSvc*     m_cgemGeomSvc;
    static CgemCalibFunSvc* m_cgemCalibFunSvc;
    const static MdcDetector*     m_mdcDetector;
};
 
typedef vector<HoughHit>::iterator HitVector_Iterator;
 
#endif