00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00013
00014 #include <cassert>
00015 #include <iostream>
00016
00017 #include "CandFitTrackSR/CandFitTrackSRHandle.h"
00018 #include "CandFitTrackSR/CandFitTrackSR.h"
00019 #include "CandFitTrackSR/KalmanPlaneSR.h"
00020 #include "CandFitTrackSR/SwimObjSR.h"
00021 #include "CandTrackSR/TrackClusterSR.h"
00022 #include "Conventions/Mphysical.h"
00023 #include "MessageService/MsgFormat.h"
00024 #include "MessageService/MsgService.h"
00025 #include "Navigation/NavKey.h"
00026 #include "Navigation/NavSet.h"
00027 #include "Plex/PlexStripEndId.h"
00028 #include "RecoBase/CandFitTrackHandle.h"
00029 #include "RecoBase/CandStripHandle.h"
00030 #include "UgliGeometry/UgliGeomHandle.h"
00031 #include "UgliGeometry/UgliScintPlnHandle.h"
00032 #include "UgliGeometry/UgliSteelPlnHandle.h"
00033 #include "Algorithm/AlgConfig.h"
00034 #include "TMath.h"
00035
00036 ClassImp(CandFitTrackSRHandle)
00037
00038
00039 CVSID("$Id: CandFitTrackSRHandle.cxx,v 1.43 2007/02/04 06:05:51 rhatcher Exp $");
00040
00041
00042 static const int kU = 0;
00043 static const int kV = 1;
00044 static const int kdUdZ = 2;
00045 static const int kdVdZ = 3;
00046 static const int kQoverP = 4;
00047
00048
00049 CandFitTrackSRHandle::CandFitTrackSRHandle()
00050 {
00051 }
00052
00053
00054 CandFitTrackSRHandle::CandFitTrackSRHandle(const CandFitTrackSRHandle &cdh) :
00055 CandFitTrackHandle(cdh)
00056 {
00057 }
00058
00059
00060 CandFitTrackSRHandle::CandFitTrackSRHandle(CandFitTrackSR *cd) :
00061 CandFitTrackHandle(cd)
00062 {
00063 }
00064
00065
00066 CandFitTrackSRHandle::~CandFitTrackSRHandle()
00067 {
00068 }
00069
00070
00071 CandFitTrackSRHandle *CandFitTrackSRHandle::DupHandle() const
00072 {
00073 return (new CandFitTrackSRHandle(*this));
00074 }
00075
00076
00077 void CandFitTrackSRHandle::Trace(const char *c) const
00078 {
00079 MSG("Cand", Msg::kDebug)
00080 << "**********Begin CandFitTrackSRHandle::Trace(\"" << c << "\")" << endl
00081 << "Information from CandFitTrackSRHandle's CandHandle: " << endl;
00082 CandHandle::Trace(c);
00083 MSG("Cand", Msg::kDebug)
00084 << "**********End CandFitTrackSRHandle::Trace(\"" << c << "\")" << endl;
00085 }
00086
00087
00088 Int_t CandFitTrackSRHandle::GetKalmanLast() const
00089 {
00090 return dynamic_cast<const CandFitTrackSR *>
00091 (GetCandBase())->fPlaneList->GetLast();
00092 }
00093
00094
00095 void CandFitTrackSRHandle::ClearKalmanPlaneList(Bool_t deletekp)
00096 {
00097 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>
00098 (GetOwnedCandBase())->fPlaneList;
00099 if(deletekp){
00100 KalmanPlaneSR *kp = 0;
00101 for(int i=0; i<=KalmanPlaneList->GetLast(); ++i){
00102 kp = dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(i));
00103 delete kp;
00104 }
00105 }
00106 KalmanPlaneList->Clear();
00107 KalmanPlaneList->Compress();
00108 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrent = 0;
00109 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrentU = 0;
00110 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrentV = 0;
00111 }
00112
00113
00114 void CandFitTrackSRHandle::ClearTrackClusterList()
00115 {
00116 TObjArray *TrackClusterList = dynamic_cast<CandFitTrackSR*>
00117 (GetOwnedCandBase())->fTrackClusterList;
00118 TrackClusterSR *tc = 0;
00119 for(int i=0; i<=TrackClusterList->GetLast(); ++i){
00120 tc = dynamic_cast<TrackClusterSR*>(TrackClusterList->At(i));
00121 delete tc;
00122 }
00123 TrackClusterList->Clear();
00124 TrackClusterList->Compress();
00125 }
00126
00127
00128 KalmanPlaneSR *CandFitTrackSRHandle::GetKalmanPlane(Int_t indx)
00129 {
00130 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>
00131 (GetOwnedCandBase())->fPlaneList;
00132 return dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(indx));
00133 }
00134
00135
00136 void CandFitTrackSRHandle::RemoveKalmanPlane(Int_t indx, Int_t idir)
00137 {
00138
00139 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>
00140 (GetOwnedCandBase())->fPlaneList;
00141 KalmanPlaneSR *kp = 0;
00142 if(indx>=0) kp = dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(indx));
00143 else {
00144 kp = GetCurrentKalmanPlane();
00145 indx = KalmanPlaneList->IndexOf(kp);
00146 }
00147 KalmanPlaneSR *newkplast = 0;
00148 if(idir==0){
00149 assert(indx-1>=0);
00150 newkplast = GetKalmanPlane(indx-1);
00151 }
00152 else{
00153 assert(indx+1<=GetKalmanLast());
00154 newkplast = GetKalmanPlane(indx+1);
00155 }
00156 SetCurrentKalmanPlane(newkplast);
00157 KalmanPlaneList->RemoveAt(indx);
00158 KalmanPlaneList->Compress();
00159 delete kp;
00160 }
00161
00162
00163 void CandFitTrackSRHandle::CompressKalmanPlaneList()
00164 {
00165 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>
00166 (GetOwnedCandBase())->fPlaneList;
00167 KalmanPlaneList->Compress();
00168 }
00169
00170
00171 KalmanPlaneSR * CandFitTrackSRHandle::AddKalmanPlaneAt(KalmanPlaneSR *kpnew, Int_t indx)
00172 {
00173 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>
00174 (GetOwnedCandBase())->fPlaneList;
00175 Int_t ilast = KalmanPlaneList->GetLast();
00176
00177
00178 KalmanPlaneSR *kpnewer = new KalmanPlaneSR(kpnew);
00179 KalmanPlaneSR *kp = 0;
00180 for(int i=ilast; i>=indx; --i){
00181 kp = dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(i));
00182 KalmanPlaneList->AddAtAndExpand(kp,i+1);
00183 }
00184 KalmanPlaneList->AddAtAndExpand(kpnewer,indx);
00185 return kpnewer;
00186 }
00187
00188
00189 void CandFitTrackSRHandle::RemoveForward(KalmanPlaneSR *kp)
00190 {
00191 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>
00192 (GetOwnedCandBase())->fPlaneList;
00193 if(!kp) kp = GetCurrentKalmanPlane();
00194 Int_t indx = KalmanPlaneList->IndexOf(kp);
00195 KalmanPlaneSR *newkplast = GetKalmanPlane(indx-1);
00196 SetCurrentKalmanPlane(newkplast);
00197 Int_t nmax = KalmanPlaneList->GetLast();
00198 for(Int_t i=indx; i<=nmax; ++i){
00199 KalmanPlaneList->RemoveAt(i);
00200 kp = dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(i));
00201 delete kp;
00202 }
00203 KalmanPlaneList->Compress();
00204 }
00205
00206
00207
00208 const KalmanPlaneSR *CandFitTrackSRHandle::GetKalmanPlane(Int_t indx) const
00209 {
00210 TObjArray *KalmanPlaneList = dynamic_cast<const CandFitTrackSR*>
00211 (GetCandBase())->fPlaneList;
00212 return dynamic_cast<const KalmanPlaneSR*>(KalmanPlaneList->At(indx));
00213 }
00214
00215
00216
00217 Double_t CandFitTrackSRHandle::GetInitialQP() const
00218 {
00219 return dynamic_cast<const CandFitTrackSR*>(GetCandBase())->fInitialQP;
00220 }
00221
00222
00223
00224 void CandFitTrackSRHandle::SetInitialQP(Double_t qp0)
00225 {
00226 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fInitialQP = qp0;
00227 }
00228
00229
00230 void CandFitTrackSRHandle::SetVtx(const KalmanPlaneSR *currentkp)
00231 {
00232 if(currentkp->GetFilStateValue(kQoverP,1)!=0)
00233 SetInitialQP(currentkp->GetFilStateValue(kQoverP,1));
00234 if(currentkp->GetFilStateValue(kU,1)!=0)
00235 SetVtxU(currentkp->GetFilStateValue(kU,1));
00236 if(currentkp->GetFilStateValue(kV,1)!=0)
00237 SetVtxV(currentkp->GetFilStateValue(kV,1));
00238 SetVtxZ(currentkp->GetTrackCluster()->GetZPos());
00239 Double_t dudz = currentkp->GetFilStateValue(kdUdZ,1);
00240 Double_t dvdz = currentkp->GetFilStateValue(kdVdZ,1);
00241 Double_t dsdz = TMath::Sqrt(1.+dudz*dudz+dvdz*dvdz)*(Double_t)(currentkp->GetZDir());
00242 if(dudz!=0) SetDirCosU(dudz/dsdz);
00243 if(dvdz!=0)SetDirCosV(dvdz/dsdz);
00244 if(dsdz!=1) SetDirCosZ(1./dsdz);
00245 SetVtxPlane(currentkp->GetTrackCluster()->GetPlane());
00246
00247 }
00248
00249
00250 void CandFitTrackSRHandle::SetEnd(const KalmanPlaneSR *currentkp)
00251 {
00252 SetEndQP(currentkp->GetFilStateValue(kQoverP,0));
00253 if(currentkp->GetFilStateValue(kU,1)!=0)
00254 SetEndU(currentkp->GetFilStateValue(kU,0));
00255 if(currentkp->GetFilStateValue(kV,1)!=0)
00256 SetEndV(currentkp->GetFilStateValue(kV,0));
00257 SetEndZ(currentkp->GetTrackCluster()->GetZPos());
00258 Double_t dudz = currentkp->GetFilStateValue(kdUdZ,0);
00259 Double_t dvdz = currentkp->GetFilStateValue(kdVdZ,0);
00260 Double_t dsdz = TMath::Sqrt(1.+dudz*dudz+dvdz*dvdz)*(Double_t)(currentkp->GetZDir());
00261 if(dudz!=0) SetEndDirCosU(dudz/dsdz);
00262 if(dvdz!=0) SetEndDirCosV(dvdz/dsdz);
00263 if(dsdz!=1) SetEndDirCosZ(1./dsdz);
00264 SetEndPlane(currentkp->GetTrackCluster()->GetPlane());
00265 }
00266
00267
00268
00269 TObjArray * CandFitTrackSRHandle::GetTrackClusterList() {
00270 return dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fTrackClusterList;
00271 }
00272
00273
00274
00275 TObjArray * CandFitTrackSRHandle::GetPlaneList(){
00276 return dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fPlaneList;
00277 }
00278
00279
00280 Int_t CandFitTrackSRHandle::GetNChangedFitPoint(){
00281 return dynamic_cast<const CandFitTrackSR*>(GetCandBase())->fNChangedFitPoint;
00282 }
00283
00284
00285 void CandFitTrackSRHandle::SetNChangedFitPoint(Int_t i){
00286 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fNChangedFitPoint=i;
00287 }
00288
00289 KalmanPlaneSR *CandFitTrackSRHandle::GetCurrentKalmanPlane(PlaneView::PlaneView_t planeview_t)
00290 {
00291 if (planeview_t==PlaneView::kU)
00292 return dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrentU;
00293 else if (planeview_t==PlaneView::kV)
00294 return dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrentV;
00295 else
00296 return dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrent;
00297
00298 }
00299
00300 const KalmanPlaneSR *CandFitTrackSRHandle::GetCurrentKalmanPlane(PlaneView::PlaneView_t planeview_t) const
00301 {
00302 if (planeview_t==PlaneView::kU)
00303 return dynamic_cast<const CandFitTrackSR*>(GetCandBase())->fCurrentU;
00304 else if (planeview_t==PlaneView::kV)
00305 return dynamic_cast<const CandFitTrackSR*>(GetCandBase())->fCurrentV;
00306 else
00307 return dynamic_cast<const CandFitTrackSR*>(GetCandBase())->fCurrent;
00308
00309 }
00310
00311
00312 void CandFitTrackSRHandle::SetCurrentKalmanPlane(KalmanPlaneSR *kp)
00313 {
00314 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrent = kp;
00315 if(kp->GetTrackCluster()->GetPlaneView()==PlaneView::kU){
00316 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrentU = kp;
00317 }
00318 else if(kp->GetTrackCluster()->GetPlaneView()==PlaneView::kV){
00319 dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fCurrentV = kp;
00320 }
00321 }
00322
00323
00324 void CandFitTrackSRHandle::AddUpstreamPlaneList(TObjArray *uplist)
00325 {
00326 Int_t nup = uplist->GetLast()+1;
00327 Int_t nmax = GetKalmanLast();
00328 TObjArray *KalmanPlaneList = dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase())->fPlaneList;
00329 KalmanPlaneSR *kp = 0;
00330 for(Int_t i=nmax; i>=0; --i){
00331 kp = dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(i));
00332 KalmanPlaneList->AddAtAndExpand(kp,i+nup);
00333 }
00334 for(Int_t i=0; i<=uplist->GetLast(); ++i){
00335 kp = dynamic_cast<KalmanPlaneSR*>(uplist->At(i));
00336 KalmanPlaneList->AddAt(kp,nup-i-1);
00337 }
00338
00339 }
00340
00341
00342 Bool_t CandFitTrackSRHandle::GetBadFit(Int_t iplane) const
00343 {
00344 map<TrackClusterSR *,Bool_t>::iterator iter;
00345 const TObjArray *KalmanPlaneList = dynamic_cast<const CandFitTrackSR*>
00346 (GetCandBase())->fPlaneList;
00347 Bool_t found(0);
00348
00349 KalmanPlaneSR *kp = 0;
00350 for(int i=0; i<=KalmanPlaneList->GetLast() && !found; ++i){
00351 kp = dynamic_cast<KalmanPlaneSR*>(KalmanPlaneList->At(i));
00352 if(kp->GetTrackCluster()->GetPlane()==iplane){
00353 found = true;
00354 iter = (dynamic_cast<const CandFitTrackSR *>
00355 (GetCandBase())->fBadFit).find(kp->GetTrackCluster());
00356
00357 if(iter!=(dynamic_cast<const CandFitTrackSR *>
00358 (GetCandBase())->fBadFit).end()){
00359 return 1;
00360 }
00361 return 0;
00362 }
00363 }
00364 return 0;
00365 }
00366
00367
00368 Bool_t CandFitTrackSRHandle::GetBadFit(TrackClusterSR *tc) const
00369 {
00370 map<TrackClusterSR *,Bool_t>::iterator iter;
00371 iter = (dynamic_cast<const CandFitTrackSR *>
00372 (GetCandBase())->fBadFit).find(tc);
00373 if (iter!=(dynamic_cast<const CandFitTrackSR *>
00374 (GetCandBase())->fBadFit).end()) {
00375 return 1;
00376 }
00377 return 0;
00378 }
00379
00380
00381 Int_t CandFitTrackSRHandle::GetNGoodFit() const
00382 {
00383 Int_t ngood=0;
00384 const KalmanPlaneSR *kp = 0;
00385 for(int i=0; i<=GetKalmanLast(); ++i){
00386 kp = GetKalmanPlane(i);
00387 if (!GetBadFit(kp->GetTrackCluster())) ngood++;
00388 }
00389 return ngood;
00390 }
00391
00392
00393 void CandFitTrackSRHandle::SetBadFit(TrackClusterSR *tc)
00394 {
00395 dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase())->fBadFit[tc] = 1;
00396 }
00397
00398
00399
00400 Float_t CandFitTrackSRHandle::GetPlanePreChi2(Int_t iplane) const
00401 {
00402 map<Int_t,Float_t>::iterator iter;
00403 iter = (dynamic_cast<const CandFitTrackSR *>(GetCandBase())->fPlanePreChi2).find(iplane);
00404 if (iter!=(dynamic_cast<const CandFitTrackSR *>(GetCandBase())->fPlanePreChi2).end()) {
00405 return dynamic_cast<const CandFitTrackSR *>(GetCandBase())->fPlanePreChi2[iplane];
00406 }
00407 return -1.;
00408 }
00409
00410
00411 void CandFitTrackSRHandle::SetPlanePreChi2(Int_t iplane, Double_t chi2)
00412 {
00413 dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase())->fPlanePreChi2[iplane] = (Float_t)chi2;
00414 }
00415
00416
00417 void CandFitTrackSRHandle::AddTrackCluster(TrackClusterSR *tc) {
00418 TrackClusterSR *newtc = new TrackClusterSR(*tc);
00419 CandFitTrackSR *track = dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase());
00420 track->fTrackClusterList->Add(newtc);
00421 }
00422
00423
00424
00425 Int_t CandFitTrackSRHandle::GetNChangedFitPoint() const
00426 {
00427 return dynamic_cast<const CandFitTrackSR *>(GetCandBase())->fNChangedFitPoint;
00428 }
00429
00430
00431 void CandFitTrackSRHandle::SetVtxExtrapolate(Int_t nplane,
00432 PlaneView::PlaneView_t planeview_t)
00433 {
00434 if(planeview_t == PlaneView::kU){
00435 dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase())->fVtxExtrapolate[0] = nplane;
00436 }
00437 else if(planeview_t == PlaneView::kV){
00438 dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase())->fVtxExtrapolate[1] = nplane;
00439 }
00440 }
00441
00442
00443 void CandFitTrackSRHandle::SetEndExtrapolate(Int_t nplane,
00444 PlaneView::PlaneView_t planeview_t)
00445 {
00446 if(planeview_t == PlaneView::kU){
00447 dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase())->fEndExtrapolate[0] = nplane;
00448 }
00449 else if (planeview_t == PlaneView::kV){
00450 dynamic_cast<CandFitTrackSR *>(GetOwnedCandBase())->fEndExtrapolate[1] = nplane;
00451 }
00452 }
00453
00454
00455 Int_t CandFitTrackSRHandle::GetVtxExtrapolate(PlaneView::PlaneView_t planeview_t) const
00456 {
00457 const CandFitTrackSR *track = dynamic_cast<const CandFitTrackSR *>(GetCandBase());
00458 if(planeview_t == PlaneView::kU){
00459 return track->fVtxExtrapolate[0];
00460 }
00461 else if(planeview_t == PlaneView::kV){
00462 return track->fVtxExtrapolate[1];
00463 }
00464 else{
00465 return min(track->fVtxExtrapolate[0],track->fVtxExtrapolate[1]);
00466 }
00467 }
00468
00469
00470 Int_t CandFitTrackSRHandle::GetEndExtrapolate(PlaneView::PlaneView_t planeview_t) const
00471 {
00472 const CandFitTrackSR *track = dynamic_cast<const CandFitTrackSR *>(GetCandBase());
00473 if(planeview_t == PlaneView::kU){
00474 return track->fEndExtrapolate[0];
00475 }
00476 else if(planeview_t == PlaneView::kV){
00477 return track->fEndExtrapolate[1];
00478 }
00479 else{
00480 return min(track->fEndExtrapolate[0],track->fEndExtrapolate[1]);
00481 }
00482 }
00483
00484
00485
00486 void CandFitTrackSRHandle::SetdUdZ(Int_t plane, Float_t ddz)
00487 {
00488 CandFitTrackSR *track = dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase());
00489 track->fdUdZ[plane] = ddz;
00490 }
00491
00492
00493 void CandFitTrackSRHandle::SetdVdZ(Int_t plane, Float_t ddz)
00494 {
00495 CandFitTrackSR *track = dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase());
00496 track->fdVdZ[plane] = ddz;
00497 }
00498
00499
00500 Float_t CandFitTrackSRHandle::GetdUdZ(Int_t plane) const
00501 {
00502 const CandFitTrackSR *track = dynamic_cast<const CandFitTrackSR*>(GetCandBase());
00503 if ((track->fdUdZ).count(plane)) {
00504 return track->fdUdZ[plane];
00505 }
00506 return -99999.;
00507 }
00508
00509
00510 Float_t CandFitTrackSRHandle::GetdVdZ(Int_t plane) const
00511 {
00512 const CandFitTrackSR *track = dynamic_cast<const CandFitTrackSR*>(GetCandBase());
00513 if ((track->fdVdZ).count(plane)) {
00514 return track->fdVdZ[plane];
00515 }
00516 return -99999.;
00517 }
00518
00519
00520
00521 void CandFitTrackSRHandle::ClearMaps()
00522 {
00523 CandFitTrackSR *track = dynamic_cast<CandFitTrackSR*>(GetOwnedCandBase());
00524 track->fdUdZ.clear();
00525 track->fdVdZ.clear();
00526 track->fPlanePreChi2.clear();
00527 CandFitTrackHandle::ClearMaps();
00528 }
00529
00530
00531 XXXITRIMP(CandFitTrackSRHandle)
