StRoot: StEvent/StEventScavenger.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StEventScavenger.cxx,v 2.10 2011/02/01 19:47:36 ullrich Exp $
00004  *
00005  * Author: Thomas Ullrich, Sep 2000
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StEventScavenger.cxx,v $
00013  * Revision 2.10  2011/02/01 19:47:36  ullrich
00014  * Added HLT branch and hooks.
00015  *
00016  * Revision 2.9  2010/08/31 19:55:13  fisyak
00017  * Remove SoftwareMonitors
00018  *
00019  * Revision 2.8  2002/01/19 00:14:16  ullrich
00020  * Corrected typo.
00021  *
00022  * Revision 2.7  2002/01/17 02:06:29  ullrich
00023  * Added the removal of objects recently added to StEvent.
00024  *
00025  * Revision 2.6  2001/06/10 21:02:49  perev
00026  * Solaris: <typeinfo> removed
00027  *
00028  * Revision 2.5  2001/04/05 04:00:49  ullrich
00029  * Replaced all (U)Long_t by (U)Int_t and all redundant ROOT typedefs.
00030  *
00031  * Revision 2.4  2001/03/16 04:59:24  ullrich
00032  * Added missing method removeTriggerDetectorCollection().
00033  *
00034  * Revision 2.3  2000/10/16 21:06:32  ullrich
00035  * Added new method: removeTpcHitsNotOnTracks()
00036  *
00037  * Revision 2.2  2000/09/27 02:53:23  ullrich
00038  * No delete, create only zombies.
00039  *
00040  * Revision 2.1  2000/09/25 18:03:13  ullrich
00041  * Initial Revision.
00042  *
00043  **************************************************************************/
00044 #include "StEventScavenger.h"
00045 #include "StEventTypes.h"
00046 
00047 bool StEventScavenger::removeEventSummary(StEvent* evt)
00048 {
00049     if (evt && evt->summary()) {
00050         evt->summary()->makeZombie();
00051         return true;
00052     }
00053     else
00054         return false;
00055 }
00056 
00057 bool StEventScavenger::removeL3Trigger(StEvent* evt)
00058 {
00059     if (evt && evt->l3Trigger()) {
00060         evt->l3Trigger()->makeZombie();
00061         return true;
00062     }
00063     else
00064         return false;
00065 }
00066 
00067 bool StEventScavenger::removeV0Vertices(StEvent* evt)
00068 {
00069     if (!evt) return false;
00070     StSPtrVecV0Vertex &vec = evt->v0Vertices();
00071     for (unsigned int i=0; i<vec.size(); i++)
00072         vec[i]->makeZombie();
00073     return true;
00074 }
00075 
00076 bool StEventScavenger::removeXiVertices(StEvent* evt)
00077 {
00078     if (!evt) return false;
00079     StSPtrVecXiVertex &vec = evt->xiVertices();
00080     for (unsigned int i=0; i<vec.size(); i++)
00081         vec[i]->makeZombie();
00082     return true;
00083 }
00084 
00085 bool StEventScavenger::removeKinkVertices(StEvent* evt)
00086 {
00087     if (!evt) return false;
00088     StSPtrVecKinkVertex &vec = evt->kinkVertices();
00089     for (unsigned int i=0; i<vec.size(); i++)
00090         vec[i]->makeZombie();
00091     return true;
00092 }
00093 
00094 bool StEventScavenger::removeCalibrationVertices(StEvent* evt)
00095 {
00096     if (!evt) return false;
00097     for (unsigned int i=0; i<evt->numberOfCalibrationVertices(); i++)
00098         evt->calibrationVertex(i)->makeZombie();
00099     return true;
00100 }
00101 
00102 bool StEventScavenger::removeTpcHitCollection(StEvent* evt)
00103 {
00104     if (evt && evt->tpcHitCollection()) {
00105         StTpcHitCollection *theHits = evt->tpcHitCollection();
00106         for (unsigned int n=0; n<theHits->numberOfSectors(); n++)
00107             for (unsigned int m=0; m<theHits->sector(n)->numberOfPadrows(); m++)
00108                 for (unsigned int h=0; h<theHits->sector(n)->padrow(m)->hits().size(); h++)
00109                     theHits->sector(n)->padrow(m)->hits()[h]->makeZombie();
00110         theHits->makeZombie();
00111         return true;
00112     }
00113     else
00114         return false;
00115 }
00116 
00117 bool StEventScavenger::removeTpcHitsNotOnTracks(StEvent* evt)
00118 {
00119     if (evt && evt->tpcHitCollection()) {
00120         // first remove all hits not associated with a track at all
00121         StTpcHitCollection *theHits = evt->tpcHitCollection();
00122         for (unsigned int n=0; n<theHits->numberOfSectors(); n++)
00123             for (unsigned int m=0; m<theHits->sector(n)->numberOfPadrows(); m++)
00124                 for (unsigned int h=0; h<theHits->sector(n)->padrow(m)->hits().size(); h++)
00125                     if (theHits->sector(n)->padrow(m)->hits()[h]->trackReferenceCount() == 0)
00126                         theHits->sector(n)->padrow(m)->hits()[h]->makeZombie();
00127         // now all hits associated with zombie tracks
00128         StSPtrVecTrackNode& nodes = evt->trackNodes();
00129         for (unsigned int i = 0; i < nodes.size(); i++) {   // loop nodes
00130             StTrackNode* node = nodes[i];
00131             for (unsigned int j = 0; j < node->entries(); j++) {   // loop tracks in node
00132                 if (node->track(j)->isZombie()) {
00133                     StTrack* track = node->track(j);
00134                     StTrackDetectorInfo* info = track->detectorInfo();
00135                     if (info) {
00136                         StPtrVecHit& hitList = info->hits();
00137                         for (unsigned int k = 0; k < hitList.size(); k++)   // loop hits
00138                             if (hitList[k]->detector() == kTpcId) hitList[k]->makeZombie();
00139                     }
00140                 }
00141             }
00142         }
00143         return true;
00144     }
00145     else
00146         return false;
00147 }
00148 
00149 bool StEventScavenger::removeFtpcHitCollection(StEvent* evt)
00150 {
00151     if (evt && evt->ftpcHitCollection()) {
00152         StFtpcHitCollection *theHits = evt->ftpcHitCollection();
00153         for (unsigned int n=0; n<theHits->numberOfPlanes(); n++)
00154             for (unsigned int m=0; m<theHits->plane(n)->numberOfSectors(); m++)
00155                 for (unsigned int h=0; h<theHits->plane(n)->sector(m)->hits().size(); h++)
00156                     theHits->plane(n)->sector(m)->hits()[h]->makeZombie();
00157         theHits->makeZombie();
00158         return true;
00159     }
00160     else
00161         return false;
00162 }
00163 
00164 bool StEventScavenger::removeSvtHitCollection(StEvent* evt)
00165 {
00166     if (evt && evt->svtHitCollection()) {
00167         StSvtHitCollection *theHits = evt->svtHitCollection();
00168         for (unsigned int n=0; n<theHits->numberOfBarrels(); n++)
00169             for (unsigned int m=0; m<theHits->barrel(n)->numberOfLadders(); m++)
00170                 for (unsigned int k=0; k<theHits->barrel(n)->ladder(k)->numberOfWafers(); k++)
00171                     for (unsigned int h=0; h<theHits->barrel(n)->ladder(m)->wafer(k)->hits().size(); h++)
00172                     theHits->barrel(n)->ladder(m)->wafer(k)->hits()[h]->makeZombie();
00173         theHits->makeZombie();
00174         return true;
00175     }
00176     else
00177         return false;
00178 }
00179 
00180 bool StEventScavenger::removeSsdHitCollection(StEvent* evt)
00181 {
00182     if (evt && evt->ssdHitCollection()) {
00183         StSsdHitCollection *theHits = evt->ssdHitCollection();
00184             for (unsigned int m=0; m<theHits->numberOfLadders(); m++)
00185                 for (unsigned int k=0; k<theHits->ladder(k)->numberOfWafers(); k++)
00186                     for (unsigned int h=0; h<theHits->ladder(m)->wafer(k)->hits().size(); h++)
00187                     theHits->ladder(m)->wafer(k)->hits()[h]->makeZombie();
00188         theHits->makeZombie();
00189         return true;
00190     }
00191     else
00192         return false;
00193 }
00194 
00195 bool StEventScavenger::removeEmcCollection(StEvent* evt)
00196 {
00197     if (evt && evt->emcCollection()) {
00198         evt->emcCollection()->makeZombie();
00199         return true;
00200     }
00201     else
00202         return false;
00203 }
00204 
00205 bool StEventScavenger::removeRichCollection(StEvent* evt)
00206 {
00207     if (evt && evt->richCollection()) {
00208         evt->richCollection()->makeZombie();
00209         return true;
00210     }
00211     else
00212         return false;
00213 }
00214 
00215 bool StEventScavenger::removeTriggerDetectorCollection(StEvent* evt)
00216 {
00217     if (evt && evt->triggerDetectorCollection()) {
00218         evt->triggerDetectorCollection()->makeZombie();
00219         return true;
00220     }
00221     else
00222         return false;
00223 }
00224 
00225 bool StEventScavenger::removeFpdCollection(StEvent* evt)
00226 {
00227     if (evt && evt->fpdCollection()) {
00228         evt->fpdCollection()->makeZombie();
00229         return true;
00230     }
00231     else
00232         return false;
00233 }
00234 
00235 bool StEventScavenger::removeTofCollection(StEvent* evt)
00236 {
00237     if (evt && evt->tofCollection()) {
00238         evt->tofCollection()->makeZombie();
00239         return true;
00240     }
00241     else
00242         return false;
00243 }
00244 
00245 bool StEventScavenger::removeHltEvent(StEvent* evt)
00246 {
00247     if (evt && evt->hltEvent()) {
00248         evt->hltEvent()->makeZombie();
00249         return true;
00250     }
00251     else
00252         return false;
00253 }
00254 
00255 bool StEventScavenger::remove(StTrack* track)
00256 {
00257     if (!track) return false;
00258 
00259     track->makeZombie();
00260 
00261     //
00262     //   Scan all tracks in node. If all are zombies we can
00263     //   make the node a zombie too. We also remove the detector
00264     //   info associated with the track if no other living
00265     //   track is using it.
00266     //
00267     StTrackNode* node = track->node();
00268     StTrackDetectorInfo* info = track->detectorInfo();
00269     unsigned int nTimesUsed  = 0;
00270     unsigned int nZombies = 0;
00271     StTrack *someTrack;
00272     if (node) {
00273         unsigned int i;
00274         for (i=0; i<node->entries(); i++) {
00275             someTrack = node->track(i);
00276             if (someTrack->isZombie()) nZombies++;
00277             if (someTrack != track && !someTrack->isZombie() &&
00278                 someTrack->detectorInfo() == info) nTimesUsed++;
00279         }
00280         if (node->entries() == nZombies) node->makeZombie();
00281     }
00282     if (info && nTimesUsed < 1) info->makeZombie();
00283 
00284     return true;
00285 }