StRoot: StEvent/StTrackDetectorInfo.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StTrackDetectorInfo.cxx,v 2.16 2009/11/23 16:34:07 fisyak Exp $
00004  *
00005  * Author: Thomas Ullrich, Sep 1999
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StTrackDetectorInfo.cxx,v $
00013  * Revision 2.16  2009/11/23 16:34:07  fisyak
00014  * Cleanup, remove dependence on dst tables, clean up software monitors
00015  *
00016  * Revision 2.15  2005/07/06 19:00:52  fisyak
00017  * Add include of StThreeVectorD.hh
00018  *
00019  * Revision 2.14  2004/10/20 18:55:13  ullrich
00020  * Name of enum changed: StStarMaxR(Z) now StStarMaxTrackRangeR(Z).
00021  *
00022  * Revision 2.13  2004/10/17 03:35:10  perev
00023  * Error check improved
00024  *
00025  * Revision 2.12  2004/10/13 16:11:59  ullrich
00026  * Added optional arg to addHit() to allow NOT to increase ref counter.
00027  *
00028  * Revision 2.11  2004/08/05 22:23:32  ullrich
00029  * Fixed bug in first argument type of setNumberOfPoints().
00030  *
00031  * Revision 2.10  2004/08/05 19:25:03  ullrich
00032  * Changes to the handling of numberOfPoints() to allow ITTF more flexibility.
00033  *
00034  * Revision 2.9  2004/07/15 16:36:26  ullrich
00035  * Removed all clone() declerations and definitions. Use StObject::clone() only.
00036  *
00037  * Revision 2.8  2003/10/30 20:07:32  perev
00038  * Check of quality added
00039  *
00040  * Revision 2.7  2001/04/05 04:00:58  ullrich`
00041  * Replaced all (U)Long_t by (U)Int_t and all redundant ROOT typedefs.
00042  *
00043  * Revision 2.6  2001/03/24 03:35:00  perev
00044  * clone() -> clone() const
00045  *
00046  * Revision 2.5  2000/04/20 13:29:58  ullrich
00047  * Added new methods and removed inconsistencies in numberOfPoints().
00048  *
00049  * Revision 2.4  2000/01/20 14:43:07  ullrich
00050  * Fixed bug in numberOfPoints(). Sum was wrong.
00051  *
00052  * Revision 2.3  1999/11/01 12:45:09  ullrich
00053  * Modified unpacking of point counter
00054  *
00055  * Revision 2.2  1999/10/28 22:27:27  ullrich
00056  * Adapted new StArray version. First version to compile on Linux and Sun.
00057  *
00058  * Revision 2.1  1999/10/13 19:45:39  ullrich
00059  * Initial Revision
00060  *
00061  **************************************************************************/
00062 #include <math.h>
00063 #include "StDetectorId.h"
00064 #include "StTrackDetectorInfo.h"
00065 #include "StFunctional.h"
00066 #include "StHit.h"
00067 #include "StThreeVectorD.hh"
00068 ClassImp(StTrackDetectorInfo)
00069 
00070 static const char rcsid[] = "$Id: StTrackDetectorInfo.cxx,v 2.16 2009/11/23 16:34:07 fisyak Exp $";
00071 
00072 StTrackDetectorInfo::StTrackDetectorInfo() : mNumberOfPoints(0),
00073                                              mNumberOfPointsTpc(0),
00074                                              mNumberOfPointsFtpcWest(0),
00075                                              mNumberOfPointsFtpcEast(0),
00076                                              mNumberOfPointsSvt(0),
00077                                              mNumberOfPointsSsd(0)
00078 { /* noop */ }
00079 
00080 StTrackDetectorInfo::~StTrackDetectorInfo() { /* noop */ }
00081 
00082 const StThreeVectorF&
00083 StTrackDetectorInfo::firstPoint() const { return mFirstPoint; }
00084 
00085 const StThreeVectorF&
00086 StTrackDetectorInfo::lastPoint() const { return mLastPoint; }
00087 
00088 unsigned short
00089 StTrackDetectorInfo::numberOfPoints() const
00090 {
00091     if (mNumberOfPoints) {
00092         return (numberOfPoints(kTpcId) +
00093                 numberOfPoints(kSvtId) +
00094                 numberOfPoints(kSsdId));
00095     }
00096     else {
00097         return (numberOfPoints(kTpcId) +
00098                 numberOfPoints(kFtpcWestId) +
00099                 numberOfPoints(kFtpcEastId) +
00100                 numberOfPoints(kSvtId) +
00101                 numberOfPoints(kSsdId));        
00102     }
00103 }
00104 
00105 unsigned short
00106 StTrackDetectorInfo::numberOfPoints(StDetectorId det) const
00107 {
00108     if (mNumberOfPoints) {    
00109         // 1*tpc + 1000*svt + 10000*ssd (Helen/Spiros Oct 29, 1999)
00110         switch (det) {
00111         case kFtpcWestId:
00112         case kFtpcEastId:
00113         case kTpcId:
00114             return mNumberOfPoints%1000;
00115             break;
00116         case kSvtId:
00117             return (mNumberOfPoints%10000)/1000;
00118             break;
00119         case kSsdId:
00120             return mNumberOfPoints/10000;
00121             break;
00122         default:
00123             return 0;
00124         }
00125     }
00126     else {
00127         switch (det) {
00128         case kFtpcWestId:
00129             return mNumberOfPointsFtpcWest;
00130             break;
00131         case kFtpcEastId:
00132             return mNumberOfPointsFtpcEast;
00133             break;
00134         case kTpcId:
00135             return mNumberOfPointsTpc;
00136             break;
00137         case kSvtId:
00138             return mNumberOfPointsSvt;
00139             break;
00140         case kSsdId:
00141             return mNumberOfPointsSsd;
00142             break;
00143         default:
00144             return 0;
00145         }
00146     }
00147 }
00148 
00149 unsigned short
00150 StTrackDetectorInfo::numberOfReferencedPoints() const
00151 {
00152     return static_cast<unsigned short>(mHits.size());
00153 }
00154 
00155 unsigned short
00156 StTrackDetectorInfo::numberOfReferencedPoints(StDetectorId id) const
00157 {
00158     unsigned short count = 0;
00159     for (StPtrVecHitConstIterator iter=mHits.begin(); iter != mHits.end(); iter++)
00160         if ((*iter)->detector() == id) count++;
00161     return count;
00162 }
00163 
00164 StPtrVecHit
00165 StTrackDetectorInfo::hits(StHitFilter& filter) const
00166 {
00167     StPtrVecHit vec;
00168     for (StPtrVecHitConstIterator iter=mHits.begin(); iter != mHits.end(); iter++)
00169         if (filter(*iter)) vec.push_back(*iter);
00170     return vec;
00171 }
00172 
00173 StPtrVecHit
00174 StTrackDetectorInfo::hits(StDetectorId id) const
00175 {
00176     StPtrVecHit vec;
00177     for (StPtrVecHitConstIterator iter=mHits.begin(); iter != mHits.end(); iter++)
00178         if ((*iter)->detector() == id) vec.push_back(*iter);
00179     return vec;
00180 }
00181 
00182 StPtrVecHit&
00183 StTrackDetectorInfo::hits() { return mHits; }
00184 
00185 const StPtrVecHit&
00186 StTrackDetectorInfo::hits() const { return mHits; }
00187 
00188 void
00189 StTrackDetectorInfo::setFirstPoint(const StThreeVectorF& val)
00190 {
00191     mFirstPoint = val;
00192 }
00193 
00194 void
00195 StTrackDetectorInfo::setLastPoint(const StThreeVectorF& val)
00196 {
00197     mLastPoint = val;
00198 }
00199 
00200 void
00201 StTrackDetectorInfo::setNumberOfPoints(unsigned short val)
00202 {
00203     mNumberOfPoints = val;
00204 }
00205 
00206 void
00207 StTrackDetectorInfo::setNumberOfPoints(unsigned char val, StDetectorId det)
00208 {
00209     mNumberOfPoints = 0;  // make sure old method is NOT active
00210     switch (det) {
00211     case kFtpcWestId:
00212         mNumberOfPointsFtpcWest = val;
00213         break;
00214     case kFtpcEastId:
00215         mNumberOfPointsFtpcEast = val;
00216         break;
00217     case kTpcId:
00218         mNumberOfPointsTpc = val;
00219         break;
00220     case kSvtId:
00221         mNumberOfPointsSvt = val;
00222         break;
00223     case kSsdId:
00224         mNumberOfPointsSsd = val;
00225         break;
00226     default:
00227         break;
00228     }
00229 }
00230 
00231 void
00232 StTrackDetectorInfo::addHit(StHit* hit, bool increaseRefCounter) // 2nd arg is optional, defaults to true
00233 {
00234     if (hit) {
00235         mHits.push_back(hit);
00236         if (increaseRefCounter) hit->setTrackReferenceCount(hit->trackReferenceCount()+1);
00237     }
00238 }
00239 
00240 void
00241 StTrackDetectorInfo::removeHit(StHit*& hit)
00242 {
00243     // carefull here: mHits.erase(&hit) is not save at all
00244     for (StPtrVecHitIterator iter=mHits.begin(); iter != mHits.end(); iter++) {
00245         if (*iter == hit) mHits.erase(iter);
00246         int i = hit->trackReferenceCount();
00247         hit->setTrackReferenceCount(i > 0 ? i-1 : 0);
00248     }
00249 }
00250 int  StTrackDetectorInfo::bad() const
00251 {
00252    int ierr;
00253    
00254    ierr = mFirstPoint.bad();
00255    if(ierr) return 1+100*ierr;
00256    ierr = mLastPoint.bad();
00257    if(ierr) return 2+100*ierr;
00258    if (fabs(mFirstPoint.z())>kStarMaxTrackRangeZ) return 21;
00259    if (fabs(mLastPoint.z ())>kStarMaxTrackRangeZ) return 22;
00260    if (mFirstPoint.perp  () >kStarMaxTrackRangeR) return 31;
00261    if (mLastPoint.perp   () >kStarMaxTrackRangeR) return 32;
00262 
00263    return 0;
00264 }