00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136 #include <map>
00137 #include "TClass.h"
00138 #include "StMath.hh"
00139 #include "StTrack.h"
00140 #include "StParticleDefinition.hh"
00141 #include "StVertex.h"
00142 #include "StTrackGeometry.h"
00143 #include "StTrackDetectorInfo.h"
00144 #include "StTrackPidTraits.h"
00145 #include "StTrackNode.h"
00146 #include "StThreeVectorD.hh"
00147 #include "StHit.h"
00148 #include "StG2TrackVertexMap.h"
00149 ClassImp(StTrack)
00150
00151 static const char rcsid[] = "$Id: StTrack.cxx,v 2.39 2012/05/07 14:42:58 fisyak Exp $";
00152
00153 StTrack::StTrack()
00154 {
00155 memset(mBeg, 0, mEnd-mBeg+1);
00156 }
00157
00158
00159 StTrack::StTrack(const StTrack& track) {
00160 for (Int_t bit = 14; bit < 23; bit++) if (track.TestBit(BIT(bit))) SetBit(BIT(bit));
00161 memcpy (mBeg, track.mBeg, mEnd-mBeg+1);
00162 mTopologyMap = track.mTopologyMap;
00163 mFitTraits = track.mFitTraits;
00164 if (track.mGeometry)
00165 mGeometry = track.mGeometry->copy();
00166 else
00167 mGeometry = 0;
00168 if (track.mOuterGeometry)
00169 mOuterGeometry = track.mOuterGeometry->copy();
00170 else
00171 mOuterGeometry = 0;
00172 mDetectorInfo = track.mDetectorInfo;
00173 mPidTraitsVec = track.mPidTraitsVec;
00174 mNode = 0;
00175 }
00176
00177 StTrack&
00178 StTrack::operator=(const StTrack& track) {
00179 if (this != &track) {
00180 for (Int_t bit = 14; bit < 23; bit++) if (track.TestBit(BIT(bit))) SetBit(BIT(bit));
00181 memcpy (mBeg, track.mBeg, mEnd-mBeg+1);
00182 mTopologyMap = track.mTopologyMap;
00183 mFitTraits = track.mFitTraits;
00184 if (mGeometry) delete mGeometry;
00185 if (track.mGeometry)
00186 mGeometry = track.mGeometry->copy();
00187 else
00188 mGeometry = 0;
00189 if (mOuterGeometry) delete mOuterGeometry;
00190 if (track.mOuterGeometry)
00191 mOuterGeometry = track.mOuterGeometry->copy();
00192 else
00193 mOuterGeometry = 0;
00194 mDetectorInfo = track.mDetectorInfo;
00195 mPidTraitsVec = track.mPidTraitsVec;
00196 }
00197 return *this;
00198 }
00199
00200 StTrack::~StTrack()
00201 {
00202 delete mGeometry;
00203 delete mOuterGeometry;
00204 }
00205
00206 Short_t
00207 StTrack::flag() const { return mFlag; }
00208
00209
00210 UShort_t
00211 StTrack::encodedMethod() const { return mEncodedMethod; }
00212
00213 bool
00214 StTrack::finderMethod(StTrackFinderMethod bit) const
00215 {
00216 return mEncodedMethod & (1<<bit);
00217 }
00218
00219 StTrackFittingMethod
00220 StTrack::fittingMethod() const
00221 {
00222 Int_t method = mEncodedMethod & 0xf;
00223 switch(method) {
00224 case kHelix2StepId:
00225 return kHelix2StepId;
00226 break;
00227 case kHelix3DId:
00228 return kHelix3DId;
00229 break;
00230 case kKalmanFitId:
00231 return kKalmanFitId;
00232 break;
00233 case kLine2StepId:
00234 return kLine2StepId;
00235 break;
00236 case kLine3DId:
00237 return kLine3DId;
00238 break;
00239 case kL3FitId:
00240 return kL3FitId;
00241 break;
00242 case kITKalmanFitId:
00243 return kITKalmanFitId;
00244 break;
00245 default:
00246 case kUndefinedFitterId:
00247 return kUndefinedFitterId;
00248 break;
00249 }
00250 }
00251
00252 float
00253 StTrack::impactParameter() const { return mImpactParameter; }
00254
00255 float
00256 StTrack::length() const { return mLength; }
00257
00258 UShort_t
00259 StTrack::numberOfPossiblePoints() const
00260 {
00261 UShort_t result;
00262 result = numberOfPossiblePoints(kTpcId) +
00263 numberOfPossiblePoints(kFtpcWestId) +
00264 numberOfPossiblePoints(kFtpcEastId) +
00265 numberOfPossiblePoints(kSvtId) +
00266 numberOfPossiblePoints(kSsdId) +
00267 numberOfPossiblePoints(kPxlId) +
00268 numberOfPossiblePoints(kIstId);
00269 if (type() == primary || type() == estPrimary) result++;
00270 return result;
00271 }
00272
00273 UShort_t
00274 StTrack::numberOfPossiblePoints(StDetectorId det) const
00275 {
00276 switch (det) {
00277 case kFtpcWestId:
00278 return mNumberOfPossiblePointsFtpcWest;
00279 break;
00280 case kFtpcEastId:
00281 return mNumberOfPossiblePointsFtpcEast;
00282 break;
00283 case kTpcId:
00284 return mNumberOfPossiblePointsTpc;
00285 break;
00286 case kSvtId:
00287 return mNumberOfPossiblePointsSvt;
00288 break;
00289 case kSsdId:
00290 return mNumberOfPossiblePointsSsd;
00291 break;
00292 case kPxlId:
00293 return mNumberOfPossiblePointsPxl;
00294 break;
00295 case kIstId:
00296 return mNumberOfPossiblePointsIst;
00297 break;
00298 default:
00299 return 0;
00300 }
00301 }
00302
00303 const StTrackTopologyMap&
00304 StTrack::topologyMap() const { return mTopologyMap; }
00305
00306 const StTrackGeometry*
00307 StTrack::geometry() const { return mGeometry; }
00308
00309 StTrackGeometry*
00310 StTrack::geometry() { return mGeometry; }
00311
00312 const StTrackGeometry*
00313 StTrack::outerGeometry() const { return mOuterGeometry; }
00314
00315 StTrackGeometry*
00316 StTrack::outerGeometry() { return mOuterGeometry; }
00317
00318 StTrackFitTraits&
00319 StTrack::fitTraits() { return mFitTraits; }
00320
00321 const StTrackFitTraits&
00322 StTrack::fitTraits() const { return mFitTraits; }
00323
00324 StTrackDetectorInfo*
00325 StTrack::detectorInfo() { return mDetectorInfo; }
00326
00327 const StTrackDetectorInfo*
00328 StTrack::detectorInfo() const { return mDetectorInfo; }
00329
00330 const StSPtrVecTrackPidTraits&
00331 StTrack::pidTraits() const { return mPidTraitsVec; }
00332
00333 StSPtrVecTrackPidTraits&
00334 StTrack::pidTraits() { return mPidTraitsVec; }
00335
00336 StPtrVecTrackPidTraits
00337 StTrack::pidTraits(StDetectorId det) const
00338 {
00339 StPtrVecTrackPidTraits vec;
00340 for (UInt_t i=0; i<mPidTraitsVec.size(); i++)
00341 if (mPidTraitsVec[i]->detector() == det)
00342 vec.push_back(mPidTraitsVec[i]);
00343 return vec;
00344 }
00345
00346 const StParticleDefinition*
00347 StTrack::pidTraits(StPidAlgorithm& pid) const
00348 {
00349 return pid(*this, mPidTraitsVec);
00350 }
00351
00352 const StTrackNode*
00353 StTrack::node() const { return mNode; }
00354
00355 StTrackNode*
00356 StTrack::node() { return mNode; }
00357
00358 void
00359 StTrack::setFlag(Short_t val) { mFlag = val; }
00360
00361
00362 void
00363 StTrack::setEncodedMethod(UShort_t val) { mEncodedMethod = val; }
00364
00365 void
00366 StTrack::setImpactParameter(Float_t val) { mImpactParameter = val; }
00367
00368 void
00369 StTrack::setLength(Float_t val) { mLength = val; }
00370
00371 void
00372 StTrack::setTopologyMap(const StTrackTopologyMap& val) { mTopologyMap = val; }
00373
00374 void
00375 StTrack::setGeometry(StTrackGeometry* val)
00376 {
00377 if (mGeometry) delete mGeometry;
00378 mGeometry = val;
00379 }
00380
00381 void
00382 StTrack::setOuterGeometry(StTrackGeometry* val)
00383 {
00384 if (mOuterGeometry) delete mOuterGeometry;
00385 mOuterGeometry = val;
00386 }
00387
00388 void
00389 StTrack::setFitTraits(const StTrackFitTraits& val) { mFitTraits = val; }
00390
00391 void
00392 StTrack::addPidTraits(StTrackPidTraits* val) { mPidTraitsVec.push_back(val); }
00393
00394 void
00395 StTrack::setDetectorInfo(StTrackDetectorInfo* val) { mDetectorInfo = val; }
00396
00397
00398 void
00399 StTrack::setNumberOfPossiblePoints(unsigned char val, StDetectorId det)
00400 {
00401 switch (det) {
00402 case kFtpcWestId:
00403 mNumberOfPossiblePointsFtpcWest = val;
00404 break;
00405 case kFtpcEastId:
00406 mNumberOfPossiblePointsFtpcEast = val;
00407 break;
00408 case kTpcId:
00409 mNumberOfPossiblePointsTpc = val;
00410 break;
00411 case kSvtId:
00412 mNumberOfPossiblePointsSvt = val;
00413 break;
00414 case kSsdId:
00415 mNumberOfPossiblePointsSsd = val;
00416 break;
00417 case kPxlId:
00418 mNumberOfPossiblePointsPxl = val;
00419 break;
00420 case kIstId:
00421 mNumberOfPossiblePointsIst = val;
00422 break;
00423 default:
00424 break;
00425 }
00426 }
00427
00428 void
00429 StTrack::setNode(StTrackNode* val) { mNode = val; }
00430
00431 #include "StHelixModel.h"
00432 Int_t StTrack::bad() const
00433 {
00434 static const double world = 1.e+5;
00435 Int_t ierr;
00436 if (!StMath::Finite(mImpactParameter)) return 12;
00437 if (!StMath::Finite(mLength) ) return 13;
00438 if (mFlag <0 ) return 21;
00439 if (mFlag ==0 ) return 31;
00440 if (::fabs(mImpactParameter)>world ) return 22;
00441 if (::fabs(mLength) >world ) return 23;
00442 if (mLength <1./world ) return 33;
00443 if (mLength > world ) return 34;
00444 if (!mGeometry ) return 24;
00445 ierr = mGeometry->bad();
00446 if (ierr ) return 4+100*ierr;
00447 if (!mOuterGeometry ) return 25;
00448 ierr = mOuterGeometry->bad();
00449 if (ierr ) return 5+100*ierr;
00450
00451 const StTrackDetectorInfo *di = mDetectorInfo;
00452 if (!di ) return 26;
00453 ierr = di->bad();
00454 if (ierr ) return 6+100*ierr;
00455 if ((flag()/100)%10 == 9) return 0;
00456 StPhysicalHelixD hlx1 = mGeometry->helix();
00457 StThreeVectorD ori2 = mOuterGeometry->origin();
00458 double len12 = hlx1.pathLength(ori2);
00459 double per = hlx1.period();
00460 while (len12< 0) len12+=per;
00461 while (len12>per) len12-=per;
00462 double tol = (len12)*0.2; if (tol<1) tol =1;
00463
00464
00465 if (fabs(hlx1.z(mLength))>kStarMaxTrackRangeZ) return 53;
00466 double qwe = pow(hlx1.x(mLength),2)+pow(hlx1.y(mLength),2);
00467 if (sqrt(qwe)>kStarMaxTrackRangeR) return 63;
00468 return 0;
00469 }
00470
00471 void StTrack::Streamer(TBuffer &R__b)
00472 {
00473
00474
00475 if (R__b.IsReading()) {
00476 UInt_t R__s, R__c;
00477 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
00478 if (R__v > 1) {
00479 Class()->ReadBuffer(R__b, this, R__v, R__s, R__c);
00480 return;
00481 }
00482
00483 StObject::Streamer(R__b);
00484 R__b >> mKey;
00485 R__b >> mFlag;
00486
00487
00488 UChar_t oldEncodedMethod;
00489 R__b >> oldEncodedMethod;
00490 mEncodedMethod=oldEncodedMethod;
00491
00492 R__b >> mImpactParameter;
00493 R__b >> mLength;
00494 R__b >> mSeedQuality;
00495 mTopologyMap.Streamer(R__b);
00496 mFitTraits.Streamer(R__b);
00497 R__b >> mGeometry;
00498
00499
00500 R__b >> (StTrackDetectorInfo*&)mDetectorInfo;
00501
00502
00503 R__b >> (StTrackNode*&)mNode;
00504
00505
00506 mPidTraitsVec.Streamer(R__b);
00507
00508 R__b.CheckByteCount(R__s, R__c, Class());
00509
00510
00511 } else {
00512 Class()->WriteBuffer(R__b,this);
00513 }
00514 }
00515
00516 void StTrack::setIdTruth()
00517 {
00518
00519 const StTrackDetectorInfo* di = detectorInfo();
00520 if (!di) return;
00521 const StPtrVecHit& vh = di->hits();
00522
00523 typedef std::map< int,float> myMap_t;
00524 typedef std::pair<int,float> myPair_t;
00525 typedef myMap_t::const_iterator myIter_t;
00526 myMap_t idTruths;
00527
00528
00529 Int_t nHits = vh.size(),id=0,qa=0;
00530 for (Int_t hi=0;hi<nHits; hi++) {
00531 const StHit* rHit = vh[hi];
00532 id = rHit->idTruth(); if (!id) continue;
00533 qa = rHit->qaTruth(); if (!qa) qa = 1;
00534 idTruths[id]+=qa;
00535 }
00536 if (! idTruths.size()) return;
00537 Int_t tkBest=-1; Float_t qaBest=0,qaSum=0;
00538 for (myIter_t it=idTruths.begin(); it!=idTruths.end();++it) {
00539 qaSum+=(*it).second;
00540 if ((*it).second<qaBest) continue;
00541 tkBest=(*it).first; qaBest=(*it).second;
00542 }
00543 if (tkBest < 0 || tkBest> 0xffff) return;
00544 Int_t avgQua= 100*qaBest/(qaSum+1e-10)+0.5;
00545 setIdTruth(tkBest,avgQua);
00546 Int_t IdVx = StG2TrackVertexMap::instance()->IdVertex(tkBest);
00547 setIdParentVx(IdVx);
00548 }
