StRoot: StEvent/StTrackNode.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StTrackNode.cxx,v 2.13 2003/11/25 04:10:47 perev Exp $
00004  *
00005  * Author: Thomas Ullrich, Sep 1999
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StTrackNode.cxx,v $
00013  * Revision 2.13  2003/11/25 04:10:47  perev
00014  * bug in erase fixed
00015  *
00016  * Revision 2.12  2003/09/02 17:58:06  perev
00017  * gcc 3.2 updates + WarnOff
00018  *
00019  * Revision 2.11  2003/04/30 20:37:06  perev
00020  * Warnings cleanup. Modified lines marked VP
00021  *
00022  * Revision 2.10  2002/04/24 02:26:57  ullrich
00023  * Replaced iterator loop by index loop in entries(StTrackType).
00024  *
00025  * Revision 2.9  2002/04/18 23:38:21  jeromel
00026  * Implementation of the SVT 2 tables scheme ...
00027  *
00028  * Revision 2.8  2001/04/05 04:00:58  ullrich
00029  * Replaced all (U)Long_t by (U)Int_t and all redundant ROOT typedefs.
00030  *
00031  * Revision 2.7  2000/08/17 00:35:27  ullrich
00032  * Added hooks for handling tpt tracks.
00033  *
00034  * Revision 2.6  2000/03/23 13:49:31  ullrich
00035  * Not implemented track type 'secondary' now handled
00036  * in a more clean way; entries(secondary) returns 0.
00037  *
00038  * Revision 2.5  1999/12/01 20:04:58  ullrich
00039  * Fixed bug in track() method.
00040  *
00041  * Revision 2.4  1999/11/09 15:44:17  ullrich
00042  * Removed method unlink() and all calls to it.
00043  *
00044  * Revision 2.3  1999/11/05 15:27:10  ullrich
00045  * Added non-const versions of several methods
00046  *
00047  * Revision 2.2  1999/10/28 22:27:44  ullrich
00048  * Adapted new StArray version. First version to compile on Linux and Sun.
00049  *
00050  * Revision 2.1  1999/10/13 19:45:44  ullrich
00051  * Initial Revision
00052  *
00053  **************************************************************************/
00054 #include <Stiostream.h>
00055 #include "StTrackNode.h"
00056 #include "StGlobalTrack.h"
00057 #include "StPrimaryTrack.h"
00058 
00059 ClassImp(StTrackNode)
00060 
00061 static const char rcsid[] = "$Id: StTrackNode.cxx,v 2.13 2003/11/25 04:10:47 perev Exp $";
00062 
00063 StTrackNode::StTrackNode() { /* noop */ }
00064 
00065 StTrackNode::~StTrackNode() { /* noop */ }
00066 
00067 void
00068 StTrackNode::addTrack(StTrack* track)
00069 {
00070     if (track) {
00071         switch (track->type()) {
00072         case primary:
00073         case estPrimary:
00074             mReferencedTracks.push_back(track);
00075             break;
00076         case secondary:                // not implemented yet
00077             cerr << "StTrackNode::addTrack(): track type 'secondary' not implemented yet." << endl;
00078             break;
00079         case global:
00080         case tpt:
00081         case estGlobal:
00082             mOwnedTracks.push_back(track);
00083             break;
00084         default:
00085             cerr << "StTrackNode::addTrack(): cannot add, unknown track type." << endl;
00086             return;
00087             break;
00088         }
00089         track->setNode(this);
00090     }
00091 }
00092 
00093 void
00094 StTrackNode::removeTrack(StTrack* track)
00095 {
00096     StPtrVecTrackIterator  iter;
00097     StSPtrVecTrackIterator iterS;
00098     if (track) {
00099         switch (track->type()) {
00100         case primary:
00101         case estPrimary:
00102             for (iter = mReferencedTracks.begin(); iter < mReferencedTracks.end(); iter++)
00103                 if (*iter == track) mReferencedTracks.erase(iter);
00104             break;
00105         case secondary:                // not implemented yet
00106             cerr << "StTrackNode::removeTrack(): track type 'secondary' not implemented yet." << endl;
00107             break;
00108         case tpt:
00109         case global:
00110         case estGlobal:
00111             for (iterS = mOwnedTracks.begin(); iterS < mOwnedTracks.end(); iterS++)
00112                 if (*iterS == track) mOwnedTracks.erase(iterS);
00113             break;
00114         default:
00115             cerr << "StTrackNode::removeTrack(): cannot remove, unknown track type." << endl;
00116             break;
00117         }
00118         track->setNode(0);
00119     }
00120 }
00121 
00122 unsigned int
00123 StTrackNode::entries() const
00124 {
00125     return mReferencedTracks.size() + mOwnedTracks.size();
00126 }
00127 
00128 const StTrack*
00129 StTrackNode::track(unsigned int i) const
00130 {
00131     if (i < mOwnedTracks.size())
00132         return mOwnedTracks[i];
00133     else {
00134         i -= mOwnedTracks.size();
00135         if (i < mReferencedTracks.size())
00136             return mReferencedTracks[i];
00137         else
00138             return 0;
00139     }
00140 }
00141 
00142 StTrack*
00143 StTrackNode::track(unsigned int i)
00144 {
00145     if (i < mOwnedTracks.size())
00146         return mOwnedTracks[i];
00147     else {
00148         i -= mOwnedTracks.size();
00149         if (i < mReferencedTracks.size())
00150             return mReferencedTracks[i];
00151         else
00152             return 0;
00153     }
00154 }
00155 
00156 unsigned int
00157 StTrackNode::entries(StTrackType type) const
00158 {
00159     unsigned int i;
00160     //VPunused StSPtrVecTrackConstIterator iterS;
00161     //VPunused StPtrVecTrackConstIterator  iter;
00162     unsigned int                counter;
00163 
00164     switch (type) {
00165     case primary:
00166     case estPrimary:
00167         for (counter=0, i=0; i < mReferencedTracks.size(); i++)
00168             if (mReferencedTracks[i]->type() == type) counter++;
00169         return counter;
00170         break;
00171     case secondary:                // not implemented yet
00172         cerr << "StTrackNode::entries(): track type 'secondary' not implemented yet." << endl;
00173         return 0;
00174         break;
00175     case tpt:
00176     case global:
00177     case estGlobal:
00178         for (counter=0, i=0; i < mOwnedTracks.size(); i++)
00179             if (mOwnedTracks[i]->type() == type) counter++;
00180         return counter;
00181         break;
00182     default:
00183         cerr << "StTrackNode::entries(): unknown track type." << endl;
00184         return 0;
00185         break;
00186     }
00187 }
00188 
00189 const StTrack*
00190 StTrackNode::track(StTrackType type, unsigned int i) const
00191 {
00192     int          j;
00193     unsigned int k;
00194 
00195     switch (type) {
00196     case primary:
00197     case estPrimary:
00198         for (j=-1, k=0; k < mReferencedTracks.size(); k++) {
00199             if (mReferencedTracks[k]->type() == type) j++;
00200             if (j == static_cast<int>(i)) return mReferencedTracks[k];
00201         }
00202         return 0;
00203         break;
00204     case secondary:                // not implemented yet
00205         cerr << "StTrackNode::track(): track type 'secondary' not implemented yet." << endl;
00206         return 0;
00207         break;
00208     case tpt:
00209     case global:
00210     case estGlobal:
00211         for (j=-1, k=0; k < mOwnedTracks.size(); k++) {
00212             if (mOwnedTracks[k]->type() == type) j++;
00213             if (j == static_cast<int>(i)) return mOwnedTracks[k];
00214         }
00215         return 0;
00216         break;
00217     default:
00218         cerr << "StTrackNode::track(): unknown track type." << endl;
00219         return 0;
00220         break;
00221     }
00222 }
00223  
00224 StTrack*
00225 StTrackNode::track(StTrackType type, unsigned int i)
00226 {
00227     int          j;
00228     unsigned int k;
00229 
00230     switch (type) {
00231     case primary:
00232     case estPrimary:
00233         for (j=-1, k=0; k < mReferencedTracks.size(); k++) {
00234             if (mReferencedTracks[k]->type() == type) j++;
00235             if (j == static_cast<int>(i)) return mReferencedTracks[k];
00236         }
00237         return 0;
00238         break;
00239     case secondary:                // not implemented yet
00240         cerr << "StTrackNode::track(): track type 'secondary' not implemented yet." << endl;
00241         return 0;
00242         break;
00243     case tpt:
00244     case global:
00245     case estGlobal:
00246         for (j=-1, k=0; k < mOwnedTracks.size(); k++) {
00247             if (mOwnedTracks[k]->type() == type) j++;
00248             if (j == static_cast<int>(i)) return mOwnedTracks[k];
00249         }
00250         return 0;
00251         break;
00252     default:
00253         cerr << "StTrackNode::track(): unknown track type." << endl;
00254         return 0;
00255         break;
00256     }
00257 }
00258