/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Muc/MucRecEvent/MucRecEvent-00-02-52/MucRecEvent/RecMucTrack.h

Go to the documentation of this file.

//$id$
//
//$log$

/*
 *    2004/03/08   Zhengyun You      Peking University
 * 
 *    2004/09/12   Zhengyun You     Peking University
 *                 transplanted to Gaudi framework
 */

#ifndef REC_MUC_TRACK_H
#define REC_MUC_TRACK_H

#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/SmartRef.h" 
#include "GaudiKernel/ObjectVector.h"
#include "EventModel/EventModel.h"
#include "Identifier/Identifier.h"
#include "ExtEvent/RecExtTrack.h"
#include "DstEvent/DstMucTrack.h"

#include "MucRecEvent/MucRecHit.h"

extern const  CLID &CLID_RecMucTrack;

class RecMucTrack : public DstMucTrack
{
 public:

  virtual const CLID& clID() const
    {
      return RecMucTrack::classID();
    }

  static const CLID& classID()
    {
      return CLID_RecMucTrack;
    }


  RecMucTrack();

  RecMucTrack& operator=(const RecMucTrack& orig);
  
  RecMucTrack(const RecMucTrack& source);

  RecMucTrack& operator=(const DstMucTrack& dstTrack);

  RecMucTrack(const DstMucTrack& dstTrack);
  
  ~RecMucTrack();

  void SetDefault();
  
  void setTrackId(const int trackId);

  void SetMdcPos(const float x,
                 const float y,
                 const float z);

  void SetMdcMomentum(const float px,
                      const float py,
                      const float pz);

  void SetExtMucPos(const float x,
                    const float y,
                    const float z);

  void SetExtMucMomentum(const float px,
                         const float py,
                         const float pz);

  void SetMucPos(const float x,
                 const float y,
                 const float z);

  void SetMucPosSigma(const float sigmax,
      const float sigmay,
      const float sigmaz);

  
  void SetMucMomentum(const float px,
                      const float py,
                      const float pz);

  void SetCurrentPos(const float x,
                     const float y,
                     const float z);

  void SetCurrentDir(const float x,
                     const float y,
                     const float z);

  void SetCurrentInsct(const float x,
                       const float y,
                       const float z);

  void SetExtTrack(RecExtTrack* extTrack);
  
  void SetExtTrackID(int id) { m_ExtTrackID = id; }

  void GetMdcExtTrack(Hep3Vector  mdcStartPos, Hep3Vector  mdcStartMomentum, int charge,
                      Hep3Vector& mucStartPos, Hep3Vector& mucStartMomentum);

 
  bool IsInsideSuperConductor(Hep3Vector pos);

  //void SetMCTrack(const BesPersTrack* mcTrack);
  
  void AttachHit(MucRecHit* hit);

  void Project(const int& part, const int& gap,
               float& x, float& y, float& z,
               int& seg);
  
  float GetHitDistance(const MucRecHit* hit);

  float GetHitDistance2(const MucRecHit* hit);

  Hep3Vector CalculateInsct(const int part,
                            const int seg,
                            const int gap);
  
  void AttachInsct(Hep3Vector insct);
  
  void AttachDirection(Hep3Vector dir);

  void CorrectDir();
  
  void CorrectPos();

  //void ProjectToReference(float& x, float& y, float& z);

  //void ProjectToZ(float& x, float& y, float& zplane);

  //void TransformPhiRToXY(const float& vk, const float& vr,
  //             const float& k0, const float& r0,
  //             float& vx, float& vy, 
  //             float& x0, float& y0) const;


  int getExtTrackID() const { return m_ExtTrackID; }
  
  Hep3Vector getExtMucPos() const { return m_ExtMucPos/10; }
  
  Hep3Vector getExtMucMomentum() const { return m_ExtMucMomentum/1000; }
  
  Hep3Vector getMucPos() const { return m_MucPos/10; }
  
  Hep3Vector getMucPosSigma() const { return m_MucPosSigma/10; }

  Hep3Vector getMucMomentum() const { return m_MucMomentum/1000; }
  
  Hep3Vector getMdcMomentum() const { return m_MdcMomentum/1000; }
  
  Hep3Vector GetCurrentPos() const { return m_CurrentPos/10; }  

  Hep3Vector GetCurrentDir() const { return m_CurrentDir/1000; }  
  
  Hep3Vector GetCurrentInsct() const { return m_CurrentInsct; } //internal  

  void ComputeLastGap();

  int brFirstLayer() const { return m_brFirstLayer; }
  
  int ecFirstLayer() const { return m_ecFirstLayer; }


  void LineFit(int fittingMethod);

  //float GetChi2() const { return m_Chi2; }

  //float GetDof() const { return m_Dof; }

  //float GetRms() const { return m_Rms; }

  void ComputeDepth();

  int ComputeDepth(int method);

  void ComputeDistanceMatch();
  
  void Extend();

  float GetDepth3() const { return m_depth_3/10; }

  void  SetRecMode(int recmode) {m_recmode = recmode;}
  
  int   GetRecMode() const {return m_recmode;}
  
  Hep3Vector  GetExtMucDistance() const { return m_Dist_muc_ext;}

  Hep3Vector  GetMucStripPos() const { return m_StripPhi;}
  
  void ComputeNGapsWithHits(); 

  int GetNGapsWithHits() const { return m_numLayers; }

  int GetTotalHits() const;

  int GetHitInGap(const int part, const int gap) const;

  int GetHitInSeg(const int part, const int seg) const;

  int GetHitInSegOrient(const int part, const int seg, const int orient) const;

  int FindSegWithMaxHits(int &part, int &seg);

  void ComputeMaxHitsInGap();

  //int GetMaxHitsInGap() const { return m_MaxHitsInLayer; }

  bool HasHit(const int part, const int seg, const int gap, const int strip) const;

  bool HasHitInGap(const int part, const int gap) const;
  
  int GetNSharedHits(const RecMucTrack* track) const;

  MucRecHit* GetHit(const int part, const int gap) const;

  vector<MucRecHit*> GetHits() const;

  vector<int> getVecHits() const { return  m_vecHits ;}
  
  vector<MucRecHit*> GetExpectedHits() const;
 
  vector<int> getExpHits() const { return  m_expHits ;}

  vector<float> getDistHits() const { return  m_distHits ;}
 
  vector<float> getQuadDistHits() const { return  m_distHits_quad ;}

  vector<float> getExtDistHits() const { return  m_distHits_ext ;} 
 
  vector<long> GetHitIndices() const;

  //BesPersTrack* GetMCTrack() const { return m_MCTrack; }

  void ComputeTrackInfo(int fittingmethod);
  
  void PrintHitsInfo() const;

  void OutputUnitChange();

  void setVecHits(vector<MucRecHit*>& pHits);

  void setExpHits(vector<MucRecHit*>& pHits);

  void setVecHits(vector<int>& vechits){ m_vecHits = vechits;}

  void setExpHits(vector<int>& exphits){ m_expHits = exphits;}  

  void setDistHits(vector<float>& disthits){ m_distHits = disthits;}

  void setQuadDistHits(vector<float>& disthits){ m_distHits_quad = disthits;}

  void setExtDistHits(vector<float>& disthits){ m_distHits_ext = disthits;}

  void pushExtDistHits(float dist){m_distHits_ext.push_back(dist);}
private:

  int       m_ExtTrackID;      // identifier of the Ext track used as seed of this track
  RecExtTrack *m_ExtTrack;        // pointer to the Ext track as seed of this track

  Hep3Vector m_MdcPos;         // Start position of the ext track in Mdc
  Hep3Vector m_MdcMomentum;    // Start Momentum of the ext track in Mdc

  Hep3Vector m_ExtMucPos;      // position of the ext track in Muc
  Hep3Vector m_ExtMucMomentum; // Momentum of the ext track in Muc

  Hep3Vector m_MucPos;         // Start position of the track in Muc
  Hep3Vector m_MucMomentum;    // Start Momentum of the track in Muc
  Hep3Vector m_MucPosSigma;
  
  Hep3Vector m_CurrentPos;     // track current position
  Hep3Vector m_CurrentDir;     // track current direction
  Hep3Vector m_CurrentInsct;   // track current intersection
  Hep3Vector m_Dist_muc_ext;
  Hep3Vector m_StripPhi;       // use to calc phi of strip in first layer

  int   m_brFirstLayer;      // first gap of the track in barrel. 20070604
  int   m_ecFirstLayer;      // first gap of the track in endcap. 20070604
  int   m_ecPart;          // whic part of endcap

  float m_depth_3;             // compare with m_depth
  int   m_recmode;             // 0: mdc ext; 1: emc ext
  int   m_Good3DLine;
  int   m_Good3DPart;
  bool  m_changeUnit;
  Hep3Vector m_IntersectionInner[9]; //intersection of this track with inner surface this gap
  Hep3Vector m_IntersectionOuter[9]; //intersection of this track with outer surface this gap

  //BesPersTrack *m_MCTrack;   // Pointer to monte carlo track
  vector<int> m_vecHits;
  vector<int> m_expHits;
  vector<float> m_distHits;
  vector<float> m_distHits_quad;
  vector<float> m_distHits_ext;
  vector<MucRecHit*> m_pHits;           // Pointers to attached hits
  vector<MucRecHit*> m_pExpectedHits;   // Pointers to expected hits
  vector<Hep3Vector> m_Intersections;   // Container of intersection points
  vector<Hep3Vector> m_Directions;      // Container of track direction on intersection points
  
};

typedef ObjectVector<RecMucTrack> RecMucTrackCol;

#endif  /* MUC_TRACK_H */

---