StRoot: StEvent/StPrimaryVertex.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StPrimaryVertex.cxx,v 2.16 2012/05/07 14:42:58 fisyak Exp $
00004  *
00005  * Author: Thomas Ullrich, Sep 1999
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StPrimaryVertex.cxx,v $
00013  * Revision 2.16  2012/05/07 14:42:58  fisyak
00014  * Add handilings for Track to Fast Detectors Matching
00015  *
00016  * Revision 2.15  2009/11/23 22:25:21  ullrich
00017  * Added new member mNumMatchesWithBTOF and related access fcts.
00018  *
00019  * Revision 2.14  2009/11/23 16:34:06  fisyak
00020  * Cleanup, remove dependence on dst tables, clean up software monitors
00021  *
00022  * Revision 2.13  2006/04/07 18:21:28  ullrich
00023  * Added data member mMeanDip incl. access functions (Marco).
00024  *
00025  * Revision 2.12  2005/07/15 20:17:35  ullrich
00026  * Corrected spelling in membrane
00027  *
00028  * Revision 2.11  2005/06/15 21:50:32  ullrich
00029  * Added members and methods to identify used vertex finder and store vertex quality.
00030  *
00031  * Revision 2.10  2004/07/15 16:36:24  ullrich
00032  * Removed all clone() declerations and definitions. Use StObject::clone() only.
00033  *
00034  * Revision 2.9  2003/09/02 17:58:05  perev
00035  * gcc 3.2 updates + WarnOff
00036  *
00037  * Revision 2.8  2002/04/18 23:38:21  jeromel
00038  * Implementation of the SVT 2 tables scheme ...
00039  *
00040  * Revision 2.7  2001/04/05 04:00:52  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:34:53  perev
00044  * clone() -> clone() const
00045  *
00046  * Revision 2.5  2000/04/03 15:30:23  ullrich
00047  * addDaughter() now assigns the right vertex, i.e. this, to
00048  * the primary tracks stored within this primary vertex.
00049  *
00050  * Revision 2.4  1999/11/09 15:44:11  ullrich
00051  * Removed method unlink() and all calls to it.
00052  *
00053  * Revision 2.3  1999/11/04 20:36:17  ullrich
00054  * New method to obtain daughter container directly
00055  *
00056  * Revision 2.2  1999/10/28 22:26:16  ullrich
00057  * Adapted new StArray version. First version to compile on Linux and Sun.
00058  *
00059  * Revision 2.1  1999/10/13 19:45:02  ullrich
00060  * Initial Revision
00061  *
00062  **************************************************************************/
00063 #include <Stiostream.h>
00064 #include "StPrimaryVertex.h"
00065 #include "StPrimaryTrack.h"
00066 #include "StTrack.h"
00067 #include "StFunctional.h"
00068 #include "StTrackNode.h"
00069 #include "StGlobalTrack.h"
00070 #include "TMath.h"
00071 #include "StTrackGeometry.h"
00072 ClassImp(StPrimaryVertex)
00073 
00074 static const char rcsid[] = "$Id: StPrimaryVertex.cxx,v 2.16 2012/05/07 14:42:58 fisyak Exp $";
00075 
00076 StPrimaryVertex::StPrimaryVertex()
00077 {init();}
00078 
00079 void StPrimaryVertex::init()
00080 {
00081     mType = kEventVtxId;
00082     mVertexFinderId = undefinedVertexFinder; 
00083     memset(mBeg, 0, mEnd-mBeg+1);
00084 }
00085 
00086 StPrimaryVertex::~StPrimaryVertex() {/* noop */};
00087 
00088 StVertexId
00089 StPrimaryVertex::type() const { return kEventVtxId; }
00090 
00091 UInt_t
00092 StPrimaryVertex::numberOfDaughters() const
00093 {
00094     return mDaughters.size();
00095 }
00096 UInt_t StPrimaryVertex::numberOfGoodTracks() const {
00097   UInt_t no = 0;
00098   for (UInt_t i=0; i<mDaughters.size(); i++) {
00099     const StTrack *track = daughter(i);
00100     if (track && track->flag() >= 0 && track->fitTraits().numberOfFitPoints() >=  NoFitPointCutForGoodTrack()) no++;
00101   }  
00102   return no;
00103 }
00104 
00105 StTrack*
00106 StPrimaryVertex::daughter(UInt_t i)
00107 {
00108     return i < mDaughters.size() ? mDaughters[i] : 0;
00109 }
00110 
00111 const StTrack*
00112 StPrimaryVertex::daughter(UInt_t i) const
00113 {
00114     return i < mDaughters.size() ? mDaughters[i] : 0;
00115 }
00116 
00117 StPtrVecTrack
00118 StPrimaryVertex::daughters(StTrackFilter& filter)
00119 {
00120     StPtrVecTrack vec;
00121     for (UInt_t i=0; i<mDaughters.size(); i++)
00122         if (filter(mDaughters[i])) vec.push_back(mDaughters[i]);
00123     return vec;
00124 }
00125 
00126 void
00127 StPrimaryVertex::addDaughter(StTrack* t)
00128 {
00129     StPrimaryTrack* p = dynamic_cast<StPrimaryTrack*>(t);
00130     if (p) {
00131         if (p->type() == primary) {
00132             mDaughters.push_back(p);
00133             p->setVertex(this);
00134         }
00135     }
00136 }
00137 
00138 void
00139 StPrimaryVertex::removeDaughter(StTrack* t)
00140 {
00141     StPrimaryTrack* p = dynamic_cast<StPrimaryTrack*>(t);
00142     if (!p) return;
00143     StSPtrVecPrimaryTrackIterator iter;
00144     if (p->type() == primary) {
00145         for (iter=mDaughters.begin(); iter != mDaughters.end(); iter++)
00146             if (*iter == t) {
00147                 mDaughters.erase(iter);
00148                 p->setVertex(0);
00149             }
00150     }
00151 }
00152 
00153 void
00154 StPrimaryVertex::setParent(StTrack*)
00155 {
00156     cerr << "StPrimaryVertex::setParent(): StPrimaryVertex cannot have a parent." << endl;
00157 }
00158 //________________________________________________________________________________
00159 void StPrimaryVertex::setTrackNumbers() {
00160   mNumMatchesWithTOF = 0;
00161   mNumMatchesWithCTB = 0;
00162   mNumMatchesWithBEMC = 0;
00163   mNumMatchesWithEEMC = 0;
00164   mNumNotMatchesWithTOF = 0;
00165   mNumNotMatchesWithCTB = 0;
00166   mNumNotMatchesWithBEMC = 0;
00167   mNumNotMatchesWithEEMC = 0;
00168   mNumTracksCrossingCentralMembrane = 0;
00169   mNumPostXTracks = 0;
00170   mNumTracksWithPromptHit = 0;
00171   mMeanDip = 0;
00172   mSumOfTrackPt = 0;
00173   UInt_t nDaughters = numberOfDaughters();
00174   UShort_t n_trk_vtx = 0;
00175   for (UInt_t i = 0; i < nDaughters; i++) {
00176     StPrimaryTrack* pTrack = (StPrimaryTrack*) daughter(i);
00177     if (! pTrack) continue;
00178     n_trk_vtx++;
00179     StThreeVectorD g3 = pTrack->geometry()->momentum();
00180     mMeanDip += TMath::PiOver2() - g3.theta();
00181     mSumOfTrackPt   += g3.perp();
00182     if (! pTrack->flagExtension()) { // check consitency with global track
00183       const StTrackNode* node = pTrack->node();
00184       const StTrack *gTrack = node->track(global);
00185       if (gTrack) pTrack->setFlagExtension(gTrack->flagExtension());
00186     }
00187     if (pTrack->isCtbMatched()    )        mNumMatchesWithCTB++;    
00188     if (pTrack->isCtbNotMatched() )        mNumNotMatchesWithCTB++; 
00189     if (pTrack->isToFMatched()    )        mNumMatchesWithTOF++;    
00190     if (pTrack->isToFNotMatched() )        mNumNotMatchesWithTOF++; 
00191     if (pTrack->isBemcMatched()   )        mNumMatchesWithBEMC++;   
00192     if (pTrack->isBemcNotMatched())        mNumNotMatchesWithBEMC++;
00193     if (pTrack->isEemcMatched()   )        mNumMatchesWithEEMC++;   
00194     if (pTrack->isEemcNotMatched())        mNumNotMatchesWithEEMC++;
00195     if (pTrack->isMembraneCrossingTrack()) mNumTracksCrossingCentralMembrane++;
00196     if (pTrack->isPostXTrack())     mNumPostXTracks++;
00197     if (pTrack-> isPromptTrack())          mNumTracksWithPromptHit++;
00198   }
00199   if (n_trk_vtx > 0) mMeanDip /= n_trk_vtx;
00200 }
00201 //________________________________________________________________________________
00202 ostream&  operator<<(ostream& os,  const StPrimaryVertex& v) {
00203   UInt_t nGoodTpcTracks = 0, nTpcTracks = 0;
00204   UInt_t nDaughters = v.numberOfDaughters();
00205   for (UInt_t i=0; i < nDaughters; i++) {
00206     StPrimaryTrack* pTrack = (StPrimaryTrack*) v.daughter(i);
00207     if (! pTrack) continue;
00208     Int_t good = (pTrack->flag() > 0 && pTrack->fitTraits().numberOfFitPoints() >=  StVertex::NoFitPointCutForGoodTrack()) ? 1 : 0;
00209     if (pTrack->fitTraits().numberOfFitPoints(kTpcId)) {
00210       nTpcTracks++; nGoodTpcTracks+=good;
00211     } 
00212   }
00213   const Char_t *beam = (v.isBeamConstrained()) ? "B" : " ";
00214   //  os << Form("%2s:C/P/X/T/E %i/%i/%i/%i/%i: %8.3f,%8.3f,%8.3f",
00215   os << Form("%1s:",beam);
00216   if (v.numPostXTracks() < 10) os << Form("%i/",v.numPostXTracks());
00217   else                                os <<       "*/";
00218   if (v.numTracksWithPromptHit() < 10) os << Form("%i/",v.numTracksWithPromptHit());
00219   else                                os <<       "*/";
00220   if (v.numTracksCrossingCentralMembrane() < 10) os << Form("%i/",v.numTracksCrossingCentralMembrane());
00221   else                                os <<       "*/";
00222   if ((v.numMatchesWithCTB()+v.numMatchesWithBTOF()) < 10) os << Form("%i/",(v.numMatchesWithCTB()+v.numMatchesWithBTOF()));
00223   else                                os <<       "*/";
00224   if ((v.numMatchesWithBEMC()+v.numMatchesWithEEMC()) < 10) os << Form("%i",(v.numMatchesWithBEMC()+v.numMatchesWithEEMC()));
00225   else                                os <<       "*";
00226   const Float_t *xyz = v.position().xyz();
00227   const Float_t *dxyz = v.positionError().xyz();
00228   for (Int_t i = 0; i < 3; i++)     os << Form("%8.3f+/-%5.3f,",xyz[i],dxyz[i]);
00229   os << " Prob/Chi2: " << Form("%5.3f/%7.2f",v.probChiSquared(),v.chiSquared())
00230      << " Rank: "      << Form("%8.3f",v.ranking())
00231      << Form(" tracks(U/T/G): %2i,%2i,%2i", v.numTracksUsedInFinder(),nDaughters,v.numberOfGoodTracks());
00232   if (nTpcTracks != nDaughters || nGoodTpcTracks != v.numberOfGoodTracks()) {
00233     os << Form(" TPC:%4i,%4i",nTpcTracks,nGoodTpcTracks);
00234   }
00235   if (v.idTruth())
00236     os << Form(" IdT: %4i Q: %4i", v.idTruth(), v.qaTruth());
00237   return os;
00238 }
00239