loon: CandRecoHandle.cxx Source File

00001 
00002 // $Id: CandRecoHandle.cxx,v 1.51 2006/08/03 18:09:12 musser Exp $
00003 //
00004 // CandRecoHandle.cxx
00005 //
00006 // CandRecoHandle is the specialized access handle to CandReco.
00007 //
00008 // Each concrete CandHandle must define a DupHandle function.
00009 //
00010 // Author:  R. Lee
00012 
00013 #include <cassert>
00014 #include <iostream>
00015 
00016 #include "Conventions/CalDigitType.h"
00017 #include "Conventions/CalTimeType.h"
00018 #include "MessageService/MsgService.h"
00019 #include "Navigation/NavKey.h"
00020 #include "Navigation/NavSet.h"
00021 #include "RecoBase/CandRecoHandle.h"
00022 #include "RecoBase/CandReco.h"
00023 #include "RecoBase/CandShowerHandle.h"
00024 #include "RecoBase/CandSliceHandle.h"
00025 #include "RecoBase/CandStripHandle.h"
00026 #include "RecoBase/CandTrackHandle.h"
00027 #include "RecoBase/Vertex.h"
00028 
00029 ClassImp(CandRecoHandle)
00030 
00031 //______________________________________________________________________
00032 CVSID("$Id: CandRecoHandle.cxx,v 1.51 2006/08/03 18:09:12 musser Exp $");
00033 
00034 //______________________________________________________________________
00035 CandRecoHandle::CandRecoHandle()
00036 {
00037 }
00038 
00039 //______________________________________________________________________
00040 CandRecoHandle::CandRecoHandle(const CandRecoHandle &cdh) :
00041   CandHandle(cdh)
00042 {
00043 }
00044 
00045 //______________________________________________________________________
00046 CandRecoHandle::CandRecoHandle(CandReco *cd) :
00047   CandHandle(cd)
00048 {
00049 }
00050 
00051 //______________________________________________________________________
00052 CandRecoHandle::~CandRecoHandle()
00053 {
00054 }
00055 
00056 //______________________________________________________________________
00057 CandRecoHandle *CandRecoHandle::DupHandle() const
00058 {
00059    return (new CandRecoHandle(*this));
00060 }
00061 
00062 //______________________________________________________________________
00063 void CandRecoHandle::Trace(const char *c) const
00064 {
00065   MSG("Cand", Msg::kDebug)
00066      << "**********Begin CandRecoHandle::Trace(\"" << c << "\")" << endl
00067             << "Information from CandRecoHandle's CandHandle: " << endl;
00068   CandHandle::Trace(c);
00069   MSG("Cand", Msg::kDebug)
00070       << "**********End CandRecoHandle::Trace(\"" << c << "\")" << endl;
00071 }
00072 
00073 //______________________________________________________________________
00074 void CandRecoHandle::SetCandSlice(const CandSliceHandle *slice)
00075 {
00076   if (slice) {                 // fCandSlice is now an owned CandHandle*
00077     CandSliceHandle *ch = slice->DupHandle();
00078     delete (dynamic_cast<CandReco *>(GetOwnedCandBase()))->fCandSlice;
00079     dynamic_cast<CandReco *>(GetOwnedCandBase())->fCandSlice = ch;
00080   }
00081 }
00082 
00083 const CandSliceHandle *CandRecoHandle::GetCandSlice() const
00084 {
00085   return dynamic_cast<const CandReco *>(GetCandBase())->fCandSlice;
00086 }
00087 
00088 CandSliceHandle *CandRecoHandle::GetCandSliceWritable()
00089 {
00090   return dynamic_cast<CandReco *>(GetOwnedCandBase())->fCandSlice;
00091 }
00092 
00093 //______________________________________________________________________
00094 
00095 Int_t CandRecoHandle::GetNStrip(PlaneView::PlaneView_t planeview_t)
00096                                                                    const
00097 {
00098   if (planeview_t==PlaneView::kUnknown) {
00099     return GetNDaughters();
00100   }
00101   Int_t n=0;
00102   TIter stripItr(GetDaughterIterator());
00103   CandStripHandle *strip;
00104   while ((strip = dynamic_cast<CandStripHandle*>(stripItr()))) {
00105     PlaneView::PlaneView_t planeview = strip->GetPlaneView();
00106     if (planeview == planeview_t) {
00107       n++;
00108     }
00109   }
00110   return n;
00111 }
00112 
00113 //______________________________________________________________________
00114 
00115 Int_t CandRecoHandle::GetNDigit(StripEnd::StripEnd_t stripend_t) const
00116 {
00117   Int_t n=0;
00118   TIter stripItr(GetDaughterIterator());
00119   CandStripHandle *strip;
00120   while ((strip = dynamic_cast<CandStripHandle*>(stripItr()))) {
00121     n += strip->GetNDigit(stripend_t);
00122   }
00123   return n;
00124 }
00125 
00126 //______________________________________________________________________
00127 
00128 Int_t CandRecoHandle::GetNStrip(const CandRecoHandle *reco,
00129   PlaneView::PlaneView_t planeview_t) const
00130 {
00131   Int_t n=0;
00132   TIter stripItr(GetDaughterIterator());
00133   CandStripHandle *strip;
00134   while ((strip = dynamic_cast<CandStripHandle*>(stripItr()))) {
00135     PlaneView::PlaneView_t planeview = strip->GetPlaneView();
00136     if ((planeview_t==PlaneView::kUnknown || planeview==planeview_t) &&
00137         reco->FindDaughter(strip)) {
00138       n++;
00139     }
00140   }
00141   return n;
00142 }
00143 
00144 //______________________________________________________________________
00145 
00146 Int_t CandRecoHandle::GetBegPlane(PlaneView::PlaneView_t planeview_t)
00147                                                                    const
00148 {
00149  if(planeview_t == PlaneView::kUnknown){
00150    Int_t iplane =  dynamic_cast<const CandReco *>
00151                                     (GetCandBase())->fVertex.GetPlane();
00152    if(iplane>=0) return iplane;
00153   }
00154   TIter stripItr(GetDaughterIterator());
00155   CandStripHandle *strip;
00156   Bool_t first(1);
00157   Int_t plane=0;
00158 
00159   Double_t dir = 1;
00160   if(this->GetVtxPlane() - this->GetTermPlane() > 0) dir = -1;
00161 
00162   while ((strip = dynamic_cast<CandStripHandle*>(stripItr()))) {
00163     PlaneView::PlaneView_t planeview = strip->GetPlaneView();
00164     if (planeview!=PlaneView::kA && planeview!=PlaneView::kB &&
00165         (planeview_t==PlaneView::kUnknown || planeview_t==planeview) &&
00166         (first || strip->GetPlane()*dir<plane*dir)) {
00167       first = 0;
00168       plane = strip->GetPlane();
00169     }
00170   }
00171   return plane;
00172 }
00173 
00174 //______________________________________________________________________
00175 Int_t CandRecoHandle::GetEndPlane(PlaneView::PlaneView_t planeview_t)
00176                                                                    const
00177 {
00178   
00179   if(planeview_t == PlaneView::kUnknown){
00180    Int_t iplane =  dynamic_cast<const CandReco *>
00181                                     (GetCandBase())->fTerm.GetPlane();
00182    if(iplane>=0) return iplane;
00183   }
00184   TIter stripItr(GetDaughterIterator());
00185   CandStripHandle *strip;
00186   Bool_t first(1);
00187   Int_t plane=0;
00188 
00189   Double_t dir = 1;
00190   if(this->GetVtxPlane() - this->GetTermPlane() > 0) dir = -1;
00191 
00192   while ((strip = dynamic_cast<CandStripHandle*>(stripItr()))) {
00193     PlaneView::PlaneView_t planeview = strip->GetPlaneView();
00194     if (planeview!=PlaneView::kA && planeview!=PlaneView::kB &&
00195         (planeview_t==PlaneView::kUnknown || planeview_t==planeview) &&
00196         (first || strip->GetPlane()*dir>plane*dir)) {
00197       first = 0;
00198       plane = strip->GetPlane();
00199     }
00200   }
00201   return plane;
00202 }
00203 
00204 //______________________________________________________________________
00205 Int_t CandRecoHandle::GetNPlane(PlaneView::PlaneView_t planeview_t)
00206                                                                    const
00207 {
00208   CandStripHandleItr stripItr(GetDaughterIterator());
00209   CandStripHandleKeyFunc *stripKf = stripItr.CreateKeyFunc();
00210   stripKf->SetFun(CandStripHandle::KeyFromPlane);
00211   stripItr.GetSet()->AdoptSortKeyFunc(stripKf);
00212   stripKf = 0;
00213 
00214   Int_t plane=0;
00215   Int_t oldplane=0;
00216   CandStripHandle *strip;
00217   while ((strip = dynamic_cast<CandStripHandle*>(stripItr()))) {
00218     PlaneView::PlaneView_t planeview = strip->GetPlaneView();
00219     if (planeview!=PlaneView::kA && planeview!=PlaneView::kB &&
00220         (planeview_t==PlaneView::kUnknown || planeview==planeview_t)) {
00221       if (!plane || strip->GetPlane()!=oldplane) {
00222         plane++;
00223       }
00224       oldplane = strip->GetPlane();
00225     }
00226   }
00227   return plane;
00228 }
00229 
00230 //______________________________________________________________________
00231 Double_t CandRecoHandle::GetCharge(CalStripType::CalStripType_t
00232                                                         caltype_t) const
00233 {
00234   Double_t charge=0.;
00235   Bool_t calstrip = kTRUE;
00236   CalDigitType::CalDigitType_t caldigittype = CalDigitType::kNone;
00237   switch (caltype_t) {
00238   case CalStripType::kNone:
00239     caldigittype = CalDigitType::kNone;
00240     calstrip = kFALSE;
00241     break;
00242   case CalStripType::kSigLin:
00243     caldigittype = CalDigitType::kSigLin;
00244     calstrip = kFALSE;
00245     break;
00246   case CalStripType::kSigCorr:
00247     caldigittype = CalDigitType::kSigCorr;
00248     calstrip = kFALSE;
00249     break;
00250   case CalStripType::kPE:
00251     caldigittype = CalDigitType::kPE;
00252     calstrip = kFALSE;
00253     break;
00254   default:
00255     calstrip = kTRUE;
00256     break;
00257   }
00258   TIter stripItr(GetDaughterIterator());
00259   const CandReco *candreco =
00260                           dynamic_cast<const CandReco *>(GetCandBase());
00261   while (const CandStripHandle *strip =
00262     dynamic_cast<const CandStripHandle*>(stripItr())) {
00263     if (!calstrip) {
00264       charge += strip->GetCharge(caldigittype);
00265     } 
00266     else {
00267       Int_t encodedNegative =
00268                  strip->GetStripEndId(StripEnd::kNegative).GetEncoded();
00269       Int_t encodedPositive =
00270                  strip->GetStripEndId(StripEnd::kPositive).GetEncoded();
00271       switch (caltype_t) {
00272       case CalStripType::kSigMapped:
00273         if ((candreco->fSigMapped).count(encodedNegative)) {
00274           charge += (candreco->fSigMapped)[encodedNegative];
00275         }
00276         if ((candreco->fSigMapped).count(encodedPositive)) {
00277           charge += (candreco->fSigMapped)[encodedPositive];
00278         }
00279         break;
00280       case CalStripType::kMIP:
00281       
00282         if ((candreco->fMIP).count(encodedNegative)) {
00283           charge += (candreco->fMIP)[encodedNegative];
00284         }
00285         if ((candreco->fMIP).count(encodedPositive)) {
00286           charge += (candreco->fMIP)[encodedPositive];
00287         }
00288         break;
00289       case CalStripType::kGeV:
00290         if ((candreco->fMIP).count(encodedNegative)) {
00291           charge += (candreco->fMIP)[encodedNegative]/18.5;
00292         }
00293         if ((candreco->fMIP).count(encodedPositive)) {
00294           charge += (candreco->fMIP)[encodedPositive]/18.5;
00295         }
00296         break;
00297       default:
00298         MSG("RecoBase",Msg::kError)
00299                       << "undefined CalStripType " << caltype_t << "\n";
00300         break;
00301       }
00302     }
00303   }
00304   return charge;
00305 }
00306 //______________________________________________________________________
00307 Double_t CandRecoHandle::GetPlaneCharge(Int_t iplane, CalStripType::CalStripType_t
00308                                                         caltype_t) const
00309 {
00310 
00311 
00312   Double_t charge=0.;
00313   Bool_t calstrip = kTRUE;
00314   CalDigitType::CalDigitType_t caldigittype = CalDigitType::kNone;
00315   switch (caltype_t) {
00316   case CalStripType::kNone:
00317     caldigittype = CalDigitType::kNone;
00318     calstrip = kFALSE;
00319     break;
00320   case CalStripType::kSigLin:
00321     caldigittype = CalDigitType::kSigLin;
00322     calstrip = kFALSE;
00323     break;
00324   case CalStripType::kSigCorr:
00325     caldigittype = CalDigitType::kSigCorr;
00326     calstrip = kFALSE;
00327     break;
00328   case CalStripType::kPE:
00329     caldigittype = CalDigitType::kPE;
00330     calstrip = kFALSE;
00331     break;
00332   default:
00333     calstrip = kTRUE;
00334     break;
00335   }
00336 
00337   CandStripHandleItr stripItr(GetDaughterIterator());
00338   CandStripHandleKeyFunc *stripKf = stripItr.CreateKeyFunc();
00339   stripKf->SetFun(CandStripHandle::KeyFromPlane);
00340   stripItr.GetSet()->AdoptSortKeyFunc(stripKf);
00341   stripKf = 0;
00342   stripItr.GetSet()->Slice(iplane);
00343   const CandReco *candreco =
00344                           dynamic_cast<const CandReco *>(GetCandBase());
00345   while (const CandStripHandle *strip =
00346     dynamic_cast<const CandStripHandle*>(stripItr())) {
00347     if(strip->GetPlane()==iplane){
00348       if (!calstrip) {
00349         charge += strip->GetCharge(caldigittype);
00350       } 
00351       else {
00352         Int_t encodedNegative =
00353           strip->GetStripEndId(StripEnd::kNegative).GetEncoded();
00354         Int_t encodedPositive =
00355           strip->GetStripEndId(StripEnd::kPositive).GetEncoded();
00356         switch (caltype_t) {
00357         case CalStripType::kSigMapped:
00358           if ((candreco->fSigMapped).count(encodedNegative)) {
00359             charge += (candreco->fSigMapped)[encodedNegative];
00360           }
00361           if ((candreco->fSigMapped).count(encodedPositive)) {
00362             charge += (candreco->fSigMapped)[encodedPositive];
00363           }
00364           break;
00365         case CalStripType::kMIP:
00366           
00367           if ((candreco->fMIP).count(encodedNegative)) {
00368             charge += (candreco->fMIP)[encodedNegative];
00369           }
00370           if ((candreco->fMIP).count(encodedPositive)) {
00371             charge += (candreco->fMIP)[encodedPositive];
00372           }
00373           break;
00374         case CalStripType::kGeV:
00375           if ((candreco->fMIP).count(encodedNegative)) {
00376             charge += (candreco->fMIP)[encodedNegative]/18.5;
00377           }
00378           if ((candreco->fMIP).count(encodedPositive)) {
00379             charge += (candreco->fMIP)[encodedPositive]/18.5;
00380           }
00381           break;
00382         default:
00383           MSG("RecoBase",Msg::kError)
00384             << "undefined CalStripType " << caltype_t << "\n";
00385           break;
00386         }
00387       }
00388     }
00389   }
00390   return charge;
00391 }
00392 
00393 //______________________________________________________________________
00394 Double_t CandRecoHandle::GetStripCharge(const CandStripHandle *strip,
00395                             CalStripType::CalStripType_t calstriptype_t,
00396                                   StripEnd::StripEnd_t stripend_t) const
00397 {
00398   if (!FindDaughter(strip)) {
00399     return 0.;
00400   }
00401   Bool_t calstrip = kTRUE;
00402   CalDigitType::CalDigitType_t caldigittype = CalDigitType::kNone;
00403   switch (calstriptype_t) {
00404   case CalStripType::kNone:
00405     caldigittype = CalDigitType::kNone;
00406     calstrip = kFALSE;
00407     break;
00408   case CalStripType::kSigLin:
00409     caldigittype = CalDigitType::kSigLin;
00410     calstrip = kFALSE;
00411     break;
00412   case CalStripType::kSigCorr:
00413     caldigittype = CalDigitType::kSigCorr;
00414     calstrip = kFALSE;
00415     break;
00416   case CalStripType::kPE:
00417     caldigittype = CalDigitType::kPE;
00418     calstrip = kFALSE;
00419     break;
00420   default:
00421     calstrip = kTRUE;
00422     break;
00423   }
00424   if (!calstrip) {
00425     return strip->GetCharge(stripend_t,caldigittype);
00426   } 
00427   else {
00428     Int_t encodedNegative =
00429                  strip->GetStripEndId(StripEnd::kNegative).GetEncoded();
00430     Int_t encodedPositive =
00431                  strip->GetStripEndId(StripEnd::kPositive).GetEncoded();
00432     const CandReco *candreco =
00433                           dynamic_cast<const CandReco *>(GetCandBase());
00434     Double_t charge=0.;
00435     switch (calstriptype_t) {
00436     case CalStripType::kSigMapped:
00437       if (stripend_t==StripEnd::kNegative ||
00438           stripend_t==StripEnd::kWhole) {
00439         if ((candreco->fSigMapped).count(encodedNegative)) {
00440           charge += (candreco->fSigMapped)[encodedNegative];
00441         }
00442       }
00443       if (stripend_t==StripEnd::kPositive ||
00444           stripend_t==StripEnd::kWhole) {
00445         if ((candreco->fSigMapped).count(encodedPositive)) {
00446           charge += (candreco->fSigMapped)[encodedPositive];
00447         }
00448       }
00449       break;
00450     case CalStripType::kMIP:
00451 
00452 // for now, kludge 1 MIP = 530 ADU - put this in db later!!!!
00453       if (stripend_t==StripEnd::kNegative ||
00454           stripend_t==StripEnd::kWhole) {
00455         if ((candreco->fMIP).count(encodedNegative)) {
00456           charge += (candreco->fMIP)[encodedNegative];
00457         }
00458       }
00459       if (stripend_t==StripEnd::kPositive ||
00460           stripend_t==StripEnd::kWhole) {
00461         if ((candreco->fMIP).count(encodedPositive)) {
00462           charge += (candreco->fMIP)[encodedPositive];
00463         }
00464       }
00465       break;
00466     case CalStripType::kGeV:
00467       if (stripend_t==StripEnd::kNegative ||
00468           stripend_t==StripEnd::kWhole) {
00469         if ((candreco->fMIP).count(encodedNegative)) {
00470           charge += (candreco->fMIP)[encodedNegative]/18.5;
00471         }
00472       }
00473       if (stripend_t==StripEnd::kPositive ||
00474           stripend_t==StripEnd::kWhole) {
00475         if ((candreco->fMIP).count(encodedPositive)) {
00476           charge += (candreco->fMIP)[encodedPositive]/18.5;
00477         }
00478       }
00479       break;
00480     default:
00481       MSG("RecoBase",Msg::kError)
00482                  << "undefined CalStripType " << calstriptype_t << "\n";
00483       break;
00484     }
00485     return charge;
00486   }
00487   return 0.;
00488 }
00489 
00490 //______________________________________________________________________
00491 Double_t CandRecoHandle::GetStripCharge(const CandStripHandle *strip,
00492                                         StripEnd::StripEnd_t stripend_t,
00493                       CalStripType::CalStripType_t calstriptype_t) const
00494 {
00495   return GetStripCharge(strip,calstriptype_t,stripend_t);
00496 }
00497 
00498 //______________________________________________________________________
00499 Double_t CandRecoHandle::GetStripCharge(const CandStripHandle *strip)
00500                                                                    const
00501 {
00502   return GetStripCharge(strip,CalStripType::kMIP,StripEnd::kWhole);
00503 }
00504 
00505 //______________________________________________________________________
00506 NavKey CandRecoHandle::KeyFromSlice(const CandRecoHandle *reco)
00507 {
00508   if (reco->GetCandSlice()) {
00509     return static_cast<Int_t>(reco->GetCandSlice()->GetUidInt());
00510   }
00511   return 0;
00512 }
00513 
00514 //______________________________________________________________________
00515 void CandRecoHandle::SetVtxU(Double_t dvar)
00516 {
00517   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVertex.SetU(dvar);
00518 }
00519 
00520 Double_t CandRecoHandle::GetVtxU() const
00521 {
00522   return dynamic_cast<const CandReco *>(GetCandBase())->fVertex.GetU();
00523 }
00524 
00525 //______________________________________________________________________
00526 
00527 void CandRecoHandle::SetVtxV(Double_t dvar)
00528 {
00529   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVertex.SetV(dvar);
00530 }
00531 
00532 Double_t CandRecoHandle::GetVtxV() const
00533 {
00534   return dynamic_cast<const CandReco *>(GetCandBase())->fVertex.GetV();
00535 }
00536 
00537 //______________________________________________________________________
00538 
00539 void CandRecoHandle::SetVtxZ(Double_t dvar)
00540 {
00541   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVertex.SetZ(dvar);
00542 }
00543 
00544 Double_t CandRecoHandle::GetVtxZ() const
00545 {
00546   return dynamic_cast<const CandReco *>(GetCandBase())->fVertex.GetZ();
00547 }
00548 
00549 //______________________________________________________________________
00550 
00551 void CandRecoHandle::SetVtxT(Double_t dvar)
00552 {
00553   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVertex.SetT(dvar);
00554 }
00555 
00556 Double_t CandRecoHandle::GetVtxT() const
00557 {
00558   return dynamic_cast<const CandReco *>(GetCandBase())->fVertex.GetT();
00559 }
00560 
00561 //______________________________________________________________________
00562 
00563 void CandRecoHandle::SetVtxPlane(Int_t ivar)
00564 {
00565   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVertex.SetPlane(ivar);
00566 }
00567 
00568 Int_t CandRecoHandle::GetVtxPlane() const
00569 {
00570   return dynamic_cast<const CandReco *>
00571                                     (GetCandBase())->fVertex.GetPlane();
00572 }
00573 
00574 //______________________________________________________________________
00575 
00576 void CandRecoHandle::SetEndU(Double_t dvar)
00577 {
00578   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTerm.SetU(dvar);
00579 }
00580 
00581 Double_t CandRecoHandle::GetEndU() const
00582 {
00583   return dynamic_cast<const CandReco *>(GetCandBase())->fTerm.GetU();
00584 }
00585 
00586 //______________________________________________________________________
00587 void CandRecoHandle::SetEndV(Double_t dvar)
00588 {
00589   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTerm.SetV(dvar);
00590 }
00591 
00592 
00593 Double_t CandRecoHandle::GetEndV() const
00594 {
00595   return dynamic_cast<const CandReco *>(GetCandBase())->fTerm.GetV();
00596 }
00597 
00598 //______________________________________________________________________
00599 void CandRecoHandle::SetEndZ(Double_t dvar)
00600 {
00601   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTerm.SetZ(dvar);
00602 }
00603 
00604 Double_t CandRecoHandle::GetEndZ() const
00605 {
00606   return dynamic_cast<const CandReco *>(GetCandBase())->fTerm.GetZ();
00607 }
00608 
00609 //______________________________________________________________________
00610 
00611 void CandRecoHandle::SetEndT(Double_t dvar)
00612 {
00613   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTerm.SetT(dvar);
00614 }
00615 
00616 Double_t CandRecoHandle::GetEndT() const
00617 {
00618   return dynamic_cast<const CandReco *>(GetCandBase())->fTerm.GetT();
00619 }
00620 
00621 //______________________________________________________________________
00622 
00623 void CandRecoHandle::SetEndPlane(Int_t ivar)
00624 {
00625   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTerm.SetPlane(ivar);
00626 }
00627 
00628 Int_t CandRecoHandle::GetTermPlane() const
00629 {
00630   return dynamic_cast<const CandReco *>
00631                                     (GetCandBase())->fTerm.GetPlane();
00632 }
00633 
00634 
00635 //______________________________________________________________________
00636 void CandRecoHandle::SetDirCosU(Double_t dvar)
00637 {
00638   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVtxDirCosU = dvar;
00639 }
00640 
00641 
00642 Double_t CandRecoHandle::GetDirCosU() const
00643 {
00644   return dynamic_cast<const CandReco *>(GetCandBase())->fVtxDirCosU;
00645 }
00646 
00647 //______________________________________________________________________
00648 
00649 void CandRecoHandle::SetDirCosV(Double_t dvar)
00650 {
00651   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVtxDirCosV = dvar;
00652 }
00653 
00654 Double_t CandRecoHandle::GetDirCosV() const
00655 {
00656   return dynamic_cast<const CandReco *>(GetCandBase())->fVtxDirCosV;
00657 }
00658 
00659 //______________________________________________________________________
00660 
00661 void CandRecoHandle::SetDirCosZ(Double_t dvar)
00662 {
00663   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVtxDirCosZ = dvar;
00664 }
00665 
00666 Double_t CandRecoHandle::GetDirCosZ() const
00667 {
00668   return dynamic_cast<const CandReco *>(GetCandBase())->fVtxDirCosZ;
00669 }
00670 
00671 //______________________________________________________________________
00672 
00673 void CandRecoHandle::SetVtxDirCosU(Double_t dvar)
00674 {
00675   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVtxDirCosU = dvar;
00676 }
00677 
00678 
00679 Double_t CandRecoHandle::GetVtxDirCosU() const
00680 {
00681   return dynamic_cast<const CandReco *>(GetCandBase())->fVtxDirCosU;
00682 }
00683 
00684 //______________________________________________________________________
00685 
00686 void CandRecoHandle::SetVtxDirCosV(Double_t dvar)
00687 {
00688   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVtxDirCosV = dvar;
00689 }
00690 
00691 Double_t CandRecoHandle::GetVtxDirCosV() const
00692 {
00693   return dynamic_cast<const CandReco *>(GetCandBase())->fVtxDirCosV;
00694 }
00695 
00696 //______________________________________________________________________
00697 
00698 void CandRecoHandle::SetVtxDirCosZ(Double_t dvar)
00699 {
00700   dynamic_cast<CandReco *>(GetOwnedCandBase())->fVtxDirCosZ = dvar;
00701 }
00702 
00703 Double_t CandRecoHandle::GetVtxDirCosZ() const
00704 {
00705   return dynamic_cast<const CandReco *>(GetCandBase())->fVtxDirCosZ;
00706 }
00707 
00708 //______________________________________________________________________
00709 
00710 void CandRecoHandle::SetEndDirCosU(Double_t dvar)
00711 {
00712   dynamic_cast<CandReco *>(GetOwnedCandBase())->fEndDirCosU = dvar;
00713 }
00714 
00715 
00716 Double_t CandRecoHandle::GetEndDirCosU() const
00717 {
00718   return dynamic_cast<const CandReco *>(GetCandBase())->fEndDirCosU;
00719 }
00720 
00721 //______________________________________________________________________
00722 
00723 void CandRecoHandle::SetEndDirCosV(Double_t dvar)
00724 {
00725   dynamic_cast<CandReco *>(GetOwnedCandBase())->fEndDirCosV = dvar;
00726 }
00727 
00728 Double_t CandRecoHandle::GetEndDirCosV() const
00729 {
00730   return dynamic_cast<const CandReco *>(GetCandBase())->fEndDirCosV;
00731 }
00732 
00733 //______________________________________________________________________
00734 
00735 void CandRecoHandle::SetEndDirCosZ(Double_t dvar)
00736 {
00737   dynamic_cast<CandReco *>(GetOwnedCandBase())->fEndDirCosZ = dvar;
00738 }
00739 
00740 Double_t CandRecoHandle::GetEndDirCosZ() const
00741 {
00742   return dynamic_cast<const CandReco *>(GetCandBase())->fEndDirCosZ;
00743 }
00744 
00745 //______________________________________________________________________
00746 
00747 void CandRecoHandle::SetTimeSlope(Double_t dvar)
00748 {
00749   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTimeSlope = dvar;
00750 }
00751 
00752 Double_t CandRecoHandle::GetTimeSlope() const
00753 {
00754   return dynamic_cast<const CandReco *>(GetCandBase())->fTimeSlope;
00755 }
00756 
00757 //______________________________________________________________________
00758 
00759 void CandRecoHandle::SetTimeOffset(Double_t dvar)
00760 {
00761   dynamic_cast<CandReco *>(GetOwnedCandBase())->fTimeOffset = dvar;
00762 }
00763 
00764 Double_t CandRecoHandle::GetTimeOffset() const
00765 {
00766   return dynamic_cast<const CandReco *>(GetCandBase())->fTimeOffset;
00767 }
00768 
00769 //______________________________________________________________________
00770 
00771 CalTimeType::CalTimeType_t CandRecoHandle::GetCalTimeType() const
00772 {
00773   TIter stripItr(GetDaughterIterator());
00774   CandStripHandle *strip = dynamic_cast<CandStripHandle*>(stripItr());
00775   if (strip) {
00776     return strip->GetCalTimeType();
00777   }
00778   else {
00779     return CalTimeType::kNone;
00780   }
00781 }
00782 
00783 //______________________________________________________________________
00784 void CandRecoHandle::CalibrateSigMapped(UInt_t encoded, Float_t ph)
00785 {
00786   CandReco *candreco = dynamic_cast<CandReco *>(GetOwnedCandBase());
00787   candreco->fSigMapped[encoded] = ph;
00788 }
00789 
00790 //______________________________________________________________________
00791 void CandRecoHandle::CalibrateMIP(UInt_t encoded, Float_t ph)
00792 {
00793   CandReco *candreco = dynamic_cast<CandReco *>(GetOwnedCandBase());
00794   candreco->fMIP[encoded] = ph;
00795 }
00796 
00797 
00798 
00799 XXXITRIMP(CandRecoHandle)