StRoot: StEvent/StTrackTopologyMap.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StTrackTopologyMap.cxx,v 2.17 2007/11/07 00:54:54 ullrich Exp $
00004  *
00005  * Author: Thomas Ullrich, Aug 1999
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  * The topo map is stored in two 32 bit words.
00011  * Cases: Depending on the context the bits have slightly
00012  *        different meaning. For FTPC tracks bit 1-20 describe
00013  *        the FTPC. There's no confusion with the TPC since
00014  *        there are only tracks in either one. Starting 2007
00015  *        the 6 layers of the SVT are re-used for the HFT.
00016  *      
00017  * 
00018  * bit             Case 1               Case 2            Case 3
00019  *--------------------------------------------------------------------
00020  *  0            primary-vertex-used
00021  *  1            SVT layer=1      FTPC-West row=1     PXL layer=1
00022  *  2            SVT layer=2      FTPC-West row=2     PXL layer=2
00023  *  3            SVT layer=3      FTPC-West row=3     IST layer=1
00024  *  4            SVT layer=4      FTPC-West row=4     IST layer=2
00025  *  5            SVT layer=5      FTPC-West row=5     IST layer=3 (?)
00026  *  6            SVT layer=6      FTPC-West row=6
00027  *  7            SSD              FTPC-West row=7
00028  *  8            TPC row=1        FTPC-West row=8
00029  *  9            TPC row=2        FTPC-West row=9
00030  *  10           TPC row=3        FTPC-West row=10
00031  *  11           TPC row=4        FTPC-East row=1
00032  *  12           TPC row=5        FTPC-East row=2
00033  *  13           TPC row=6        FTPC-East row=3
00034  *  14           TPC row=7        FTPC-East row=4
00035  *  15           TPC row=8        FTPC-East row=5
00036  *  16           TPC row=9        FTPC-East row=6
00037  *  17           TPC row=10       FTPC-East row=7
00038  *  18           TPC row=11       FTPC-East row=8
00039  *  19           TPC row=12       FTPC-East row=9
00040  *  20           TPC row=13       FTPC-East row=10
00041  *  21           TPC row=14
00042  *  22           TPC row=15
00043  *  23           TPC row=16
00044  *  24           TPC row=17
00045  *  25           TPC row=18
00046  *  26           TPC row=19
00047  *  27           TPC row=20
00048  *  28           TPC row=21
00049  *  29           TPC row=22
00050  *  30           TPC row=23
00051  *  31           TPC row=24
00052  *  -------------------------- word boundary
00053  *  32     0     TPC row=25
00054  *  33     1     TPC row=26
00055  *  34     2     TPC row=27
00056  *  35     3     TPC row=28
00057  *  36     4     TPC row=29
00058  *  37     5     TPC row=30
00059  *  38     6     TPC row=31
00060  *  39     7     TPC row=32
00061  *  40     8     TPC row=33
00062  *  41     9     TPC row=34
00063  *  42     10    TPC row=35
00064  *  43     11    TPC row=36
00065  *  44     12    TPC row=37
00066  *  45     13    TPC row=38
00067  *  46     14    TPC row=39
00068  *  47     15    TPC row=40
00069  *  48     16    TPC row=41
00070  *  49     17    TPC row=42
00071  *  50     18    TPC row=43
00072  *  51     19    TPC row=44
00073  *  52     20    TPC row=45
00074  *  53     21    Mwpc
00075  *  54     22    CTB
00076  *  55     23    ToF
00077  *  56     24    RICH
00078  *  57     25    Barrel EMC/SMD
00079  *  58     26    Endcap EMC/SMD
00080  *  59     27
00081  *  60     28
00082  *  61     29
00083  *  62     30    turn around flag  (flags that track spirals back)
00084  *  63     31    FTPC Format (flags TOC or FTPC)
00085  *
00086  ***************************************************************************
00087  *
00088  * $Log: StTrackTopologyMap.cxx,v $
00089  * Revision 2.17  2007/11/07 00:54:54  ullrich
00090  * Added PXL and IST.
00091  *
00092  * Revision 2.16  2005/06/23 19:04:24  ullrich
00093  * Added overloaded version of hasHitInDetector() taking up to 6 args.
00094  *
00095  * Revision 2.15  2004/08/11 05:21:22  genevb
00096  * tpcOnly excludes SSD
00097  *
00098  * Revision 2.14  2002/03/18 17:11:31  jeromel
00099  * Typo found by Jamie while testing P02gd. Corrected.
00100  *
00101  * Revision 2.13  2001/05/10 19:12:15  genevb
00102  * Switch FTPC definitions
00103  *
00104  * Revision 2.12  2001/04/24 21:32:07  genevb
00105  * Additional helper functions
00106  *
00107  * Revision 2.11  2001/04/05 04:00:58  ullrich
00108  * Replaced all (U)Long_t by (U)Int_t and all redundant ROOT typedefs.
00109  *
00110  * Revision 2.10  2000/12/08 20:21:08  genevb
00111  * Changed kTofPatchId -> kTofId
00112  *
00113  * Revision 2.9  2000/07/28 19:49:28  akio
00114  * Change in Detector Id for Endcap SMD
00115  *
00116  * Revision 2.8  2000/05/17 17:21:34  ullrich
00117  * New method largestGap() and new output operator.
00118  *
00119  * Revision 2.7  2000/04/12 19:44:03  genevb
00120  * Reimplement mMap data members as individual unsigned ints
00121  *
00122  * Revision 2.6  2000/04/10 19:59:33  genevb
00123  * StRoot/StEvent/doc/tex/
00124  *
00125  * Revision 2.5  2000/03/29 00:16:30  ullrich
00126  * Fixed off-by-one error.
00127  *
00128  * Revision 2.4  2000/01/07 18:20:34  ullrich
00129  * Buf fixed. Wrong indices for mMap in bit().
00130  *
00131  * Revision 2.3  1999/12/13 20:16:36  ullrich
00132  * Changed numbering scheme for hw_position unpack methods (STAR conventions).
00133  *
00134  * Revision 2.2  1999/10/28 22:27:55  ullrich
00135  * Adapted new StArray version. First version to compile on Linux and Sun.
00136  *
00137  * Revision 2.1  1999/10/13 19:45:46  ullrich
00138  * Initial Revision
00139  *
00140  **************************************************************************/
00141 #include "StTrackTopologyMap.h"
00142 #include <vector>
00143 #include <algorithm>
00144 #include <numeric>
00145 #if !defined(ST_NO_NAMESPACES)
00146 using std::vector;
00147 using std::adjacent_difference;
00148 using std::max_element;
00149 #endif
00150 
00151 static const char rcsid[] = "$Id: StTrackTopologyMap.cxx,v 2.17 2007/11/07 00:54:54 ullrich Exp $";
00152 
00153 ClassImp(StTrackTopologyMap)
00154 
00155 StTrackTopologyMap::StTrackTopologyMap()
00156 {
00157     mMap0 = mMap1 = 0;
00158 }
00159 
00160 StTrackTopologyMap::StTrackTopologyMap(unsigned int m1, unsigned int m2) : mMap0(m1), mMap1(m2) { /* noop */ }
00161 
00162 StTrackTopologyMap::StTrackTopologyMap(const unsigned int* m) : mMap0(m[0]), mMap1(m[1]) { /* noop */ }
00163 
00164 StTrackTopologyMap::StTrackTopologyMap(const unsigned long* m) : mMap0(m[0]), mMap1(m[1]) { /* noop */ }
00165 
00166 StTrackTopologyMap::~StTrackTopologyMap() { /* noop */ }
00167 
00168 bool
00169 StTrackTopologyMap::bit(int i) const
00170 {
00171     return i>31 ? (mMap1>>(i-32) & 1U) : (mMap0>>i & 1U);
00172 }
00173 
00174 bool
00175 StTrackTopologyMap::ftpcFormat() const
00176 {
00177     return bit(63);
00178 }
00179 
00180 unsigned int
00181 StTrackTopologyMap::data(unsigned int i) const
00182 {
00183     return static_cast<unsigned int>(i<2 ? (i<1 ? mMap0 : mMap1) : 0);
00184 }
00185 
00186 bool
00187 StTrackTopologyMap::primaryVertexUsed() const { return bit(0); }
00188 
00189 bool
00190 StTrackTopologyMap::turnAroundFlag() const { return bit(62); }
00191 
00192 bool
00193 StTrackTopologyMap::hasHitInDetector(StDetectorId id) const
00194 {
00195     return ((numberOfHits(id)) ? 1U : 0U);
00196 }
00197 
00198 
00199 bool
00200 StTrackTopologyMap::hasHitInDetector(StDetectorId d1, StDetectorId d2,
00201                                StDetectorId d3, StDetectorId d4,
00202                                StDetectorId d5, StDetectorId d6) const
00203 {
00204     //
00205     //  Note d3 - d6 are optional, if not given they will have
00206     //  the value kUnknownId and shouldn't be used.
00207     //
00208     return (hasHitInDetector(d1) && hasHitInDetector(d2) &&
00209           (d3 == kUnknownId ? true : hasHitInDetector(d3)) &&
00210           (d4 == kUnknownId ? true : hasHitInDetector(d4)) &&
00211           (d5 == kUnknownId ? true : hasHitInDetector(d5)) &&
00212           (d6 == kUnknownId ? true : hasHitInDetector(d6)));
00213 }
00214 
00215 bool
00216 StTrackTopologyMap::hasHitInSvtLayer(unsigned int layer) const
00217 {
00218     if (ftpcFormat())
00219         return false;
00220     else
00221         return bit(layer);
00222 }
00223 
00224 bool
00225 StTrackTopologyMap::hasHitInPxlLayer(unsigned int layer) const
00226 {
00227     if(ftpcFormat())
00228         return false;
00229     else
00230         return bit(layer);
00231 }
00232 
00233 bool
00234 StTrackTopologyMap::hasHitInIstLayer(unsigned int layer) const
00235 {
00236     if(ftpcFormat())
00237         return false;
00238     else
00239         return bit(layer+2);
00240 }
00241 
00242 bool
00243 StTrackTopologyMap::hasHitInRow(StDetectorId id, unsigned int row) const
00244 {
00245     switch (id) {
00246     case kTpcId:
00247         return !ftpcFormat() && bit(row+7);
00248         break;
00249     case kFtpcWestId:
00250         return ftpcFormat() && bit(row);
00251         break;
00252     case kFtpcEastId:
00253         return ftpcFormat() && bit(row+10);
00254         break;
00255     default:
00256         return false;
00257         break;
00258     }
00259 }
00260 
00261 unsigned int
00262 StTrackTopologyMap::numberOfHits(StDetectorId id) const
00263 {
00264     if (ftpcFormat() &&
00265         !(id == kFtpcWestId || id == kFtpcEastId))
00266         return 0;
00267     
00268     int i;
00269     int n = 0;
00270 
00271     switch (id) {
00272     case kSvtId:
00273         for (i=1; i<7; i++)
00274             if (hasHitInSvtLayer(i)) n++;
00275         break;
00276     case kSsdId:
00277         if (bit(7)) n++;
00278         break;
00279     case kPxlId:
00280         for(i=1;i<3;i++)
00281           if(hasHitInPxlLayer(i)) n++;
00282         break;
00283     case kIstId:
00284         for(i=1;i<4;i++)
00285           if(hasHitInIstLayer(i)) n++;
00286         break;
00287     case kFtpcWestId:
00288     case kFtpcEastId:
00289         for (i=1; i<11; i++)
00290             if (hasHitInRow(id, i)) n++;
00291         break;
00292     case kTpcId:
00293         for (i=1; i<46; i++)
00294             if (hasHitInRow(id, i)) n++;
00295         break;
00296     case kMwpcWestId:
00297     case kMwpcEastId:
00298         if (bit(53)) n++;
00299         break;
00300     case kCtbId:
00301         if (bit(54)) n++;
00302         break;
00303     case kTofId:
00304         if (bit(55)) n++;
00305         break;
00306     case kRichId:
00307         if (bit(56)) n++;
00308         break;
00309     case kBarrelEmcTowerId:
00310     case kBarrelEmcPreShowerId:
00311     case kBarrelSmdEtaStripId:
00312     case kBarrelSmdPhiStripId:
00313         if (bit(57)) n++;
00314         break;
00315     case kEndcapEmcTowerId:
00316     case kEndcapEmcPreShowerId:
00317     case kEndcapSmdUStripId:
00318     case kEndcapSmdVStripId:
00319         if (bit(58)) n++;
00320         break;
00321     default:
00322         n = 0;
00323         break;
00324     }
00325     return n;
00326 }
00327 
00328 bool
00329 StTrackTopologyMap::trackTpcOnly() const
00330 {
00331     return ((hasHitInDetector(kTpcId)) &
00332            ~((hasHitInDetector(kSvtId)) | (hasHitInDetector(kSsdId))));
00333 }
00334 
00335 bool
00336 StTrackTopologyMap::trackSvtOnly() const
00337 {
00338     return ((hasHitInDetector(kSvtId)) & ~(hasHitInDetector(kTpcId)));
00339 }
00340 
00341 bool
00342 StTrackTopologyMap::trackTpcSvt() const
00343 {
00344     return ((hasHitInDetector(kTpcId)) & (hasHitInDetector(kSvtId)));
00345 }
00346 
00347 bool
00348 StTrackTopologyMap::trackFtpcEast() const
00349 {
00350     return (hasHitInDetector(kFtpcEastId));
00351 }
00352 
00353 bool
00354 StTrackTopologyMap::trackFtpcWest() const
00355 {
00356     return (hasHitInDetector(kFtpcWestId));
00357 }
00358 
00359 bool
00360 StTrackTopologyMap::trackFtpc() const
00361 {
00362     return ((hasHitInDetector(kFtpcWestId)) | (hasHitInDetector(kFtpcEastId)));
00363 }
00364 
00365 int
00366 StTrackTopologyMap::largestGap(StDetectorId id) const
00367 {
00368     if (ftpcFormat() && !(id == kFtpcWestId || id == kFtpcEastId))
00369         return -1;
00370 
00371     vector<int> rows;
00372     int i;
00373 
00374     switch (id) {
00375     case kSvtId:
00376         for (i=1; i<7; i++)
00377             if (hasHitInSvtLayer(i)) rows.push_back(i);
00378         break;
00379     case kIstId:
00380         for (i=1; i<4; i++)
00381             if (hasHitInIstLayer(i)) rows.push_back(i);
00382         break;
00383     case kFtpcWestId:
00384     case kFtpcEastId:
00385         for (i=1; i<11; i++)
00386             if (hasHitInRow(id, i)) rows.push_back(i);
00387         break;
00388     case kTpcId:
00389         for (i=1; i<46; i++)
00390             if (hasHitInRow(id, i)) rows.push_back(i);
00391         break;
00392     default:
00393         return -1;
00394     }
00395 
00396     if (rows.size() < 2) return -1;
00397 
00398     vector<int> diffs(rows.size());
00399     adjacent_difference(rows.begin(), rows.end(), diffs.begin());
00400     return *max_element(diffs.begin()+1, diffs.end()) - 1;  // skip first
00401 }
00402 
00403 ostream& operator<< (ostream& os, const StTrackTopologyMap& m)
00404 {
00405     for (int i=0; i<64; i++) {
00406         if (i>31)
00407             os << ((m.data(1)>>(i-32) & 1U) ? 1 : 0);
00408         else
00409             os << ((m.data(0)>>i & 1U) ? 1 : 0);
00410     }
00411     return os;
00412 }
00413