WCSimVertexGeometry.hh

Go to the documentation of this file.
00001 #ifndef WCSIMVERTEXGEOMETRY_HH
00002 #define WCSIMVERTEXGEOMETRY_HH
00003 
00004 #include "TObject.h"
00005 
00006 #include <vector>
00007 
00008 class WCSimRecoVertex;
00009 class WCSimRecoEvent;
00010 
00011 class WCSimVertexGeometry : public TObject {
00012 
00013  public:
00014   static WCSimVertexGeometry* Instance();
00015 
00016   void LoadEvent(WCSimRecoEvent* evt);
00017 
00018   void CalcResiduals(WCSimRecoEvent* evt, WCSimRecoVertex* vtx);
00019   void CalcResiduals(WCSimRecoVertex* vtx);
00020   void CalcResiduals(Double_t vx, Double_t vy, Double_t vz, Double_t vtxTime,
00021                       Double_t px, Double_t py, Double_t pz);
00022 
00023   void CalcPointResiduals(Double_t vx, Double_t vy, Double_t vz, Double_t vtxTime,
00024                            Double_t px, Double_t py, Double_t pz);
00025   void CalcExtendedResiduals(Double_t vx, Double_t vy, Double_t vz, Double_t vtxTime,
00026                               Double_t px, Double_t py, Double_t pz);
00027 
00028   void CalcVertexSeeds(WCSimRecoEvent* evt, Int_t NSeeds = 1);
00029   void CalcVertexSeeds(Int_t NSeeds = 1);
00030 
00031   WCSimRecoVertex* CalcSimpleVertex(WCSimRecoEvent* evt);
00032   WCSimRecoVertex* CalcSimpleVertex();
00033 
00034   WCSimRecoVertex* CalcSimpleDirection(WCSimRecoEvent* evt, WCSimRecoVertex* vtx);
00035   WCSimRecoVertex* CalcSimpleDirection(WCSimRecoVertex* vtx);
00036 
00037   Int_t GetNDigits() { return fNDigits; }
00038   Int_t GetNFilterDigits() { return fNFilterDigits; }
00039 
00040   Bool_t IsFiltered(Int_t idigit) { 
00041     if( idigit>=0 && idigit<fNDigits ) {
00042       return fIsFiltered[idigit]; 
00043     }
00044     else return 0;
00045   }
00046 
00047   Double_t GetDigitX(Int_t idigit) { 
00048     if( idigit>=0 && idigit<fNDigits ) {
00049       return fDigitX[idigit]; 
00050     }
00051     else return 0.0;
00052   }
00053 
00054   Double_t GetDigitY(Int_t idigit) { 
00055     if( idigit>=0 && idigit<fNDigits ) {
00056       return fDigitY[idigit]; 
00057     }
00058     else return 0.0;
00059   }
00060 
00061   Double_t GetDigitZ(Int_t idigit) { 
00062     if( idigit>=0 && idigit<fNDigits ) {
00063       return fDigitZ[idigit]; 
00064     }
00065     else return 0.0;
00066   }
00067 
00068   Double_t GetDigitT(Int_t idigit) { 
00069     if( idigit>=0 && idigit<fNDigits ) {
00070       return fDigitT[idigit]; 
00071     }
00072     else return 0.0;
00073   }
00074 
00075   Double_t GetDigitQ(Int_t idigit) { 
00076     if( idigit>=0 && idigit<fNDigits ) {
00077       return fDigitQ[idigit]; 
00078     }
00079     else return 0.0;
00080   }
00081 
00082   Double_t GetConeAngle(Int_t idigit) { 
00083     if( idigit>=0 && idigit<fNDigits ) {
00084       return fConeAngle[idigit]; 
00085     }
00086     else return 0.0;
00087   }
00088 
00089   Double_t GetAngle(Int_t idigit) { 
00090     return GetZenith(idigit);
00091   }
00092 
00093   Double_t GetZenith(Int_t idigit) { 
00094     if( idigit>=0 && idigit<fNDigits ) {
00095       return fZenith[idigit]; 
00096     }
00097     else return 0.0;
00098   }
00099 
00100   Double_t GetAzimuth(Int_t idigit) { 
00101     if( idigit>=0 && idigit<fNDigits ) {
00102       return fAzimuth[idigit]; 
00103     }
00104     else return 0.0;
00105   }
00106 
00107   Double_t GetSolidAngle(Int_t idigit) { 
00108     if( idigit>=0 && idigit<fNDigits ) {
00109       return fSolidAngle[idigit]; 
00110     }
00111     else return 0.0;
00112   }
00113 
00114   Double_t GetDistPoint(Int_t idigit) { 
00115     if( idigit>=0 && idigit<fNDigits ) {
00116       return fDistPoint[idigit]; 
00117     }
00118     else return 0.0;
00119   }
00120 
00121   Double_t GetDistTrack(Int_t idigit) { 
00122     if( idigit>=0 && idigit<fNDigits ) {
00123       return fDistTrack[idigit]; 
00124     }
00125     else return 0.0;
00126   }
00127 
00128   Double_t GetDistPhoton(Int_t idigit) { 
00129     if( idigit>=0 && idigit<fNDigits ) {
00130       return fDistPhoton[idigit]; 
00131     }
00132     else return 0.0;
00133   }
00134 
00135   Double_t GetDistScatter(Int_t idigit) { 
00136     if( idigit>=0 && idigit<fNDigits ) {
00137       return fDistScatter[idigit]; 
00138     }
00139     else return 0.0;
00140   }
00141 
00142   Double_t GetDeltaTime(Int_t idigit) { 
00143     if( idigit>=0 && idigit<fNDigits ) {
00144       return fDeltaTime[idigit]; 
00145     }
00146     else return 0.0;
00147   }
00148 
00149   Double_t GetDeltaSigma(Int_t idigit) { 
00150     if( idigit>=0 && idigit<fNDigits ) {
00151       return fDeltaSigma[idigit]; 
00152     }
00153     else return 0.0;
00154   }
00155 
00156   Double_t GetDeltaAngle(Int_t idigit) { 
00157     if( idigit>=0 && idigit<fNDigits ) {
00158       return fDeltaAngle[idigit]; 
00159     }
00160     else return 0.0;
00161   }
00162 
00163   Double_t GetDeltaPoint(Int_t idigit) { 
00164     if( idigit>=0 && idigit<fNDigits ) {
00165       return fDeltaPoint[idigit]; 
00166     }
00167     else return 0.0;
00168   }
00169 
00170   Double_t GetDeltaTrack(Int_t idigit) { 
00171     if( idigit>=0 && idigit<fNDigits ) {
00172       return fDeltaTrack[idigit]; 
00173     }
00174     else return 0.0;
00175   }
00176 
00177   Double_t GetDeltaPhoton(Int_t idigit) { 
00178     if( idigit>=0 && idigit<fNDigits ) {
00179       return fDeltaPhoton[idigit]; 
00180     }
00181     else return 0.0;
00182   }  
00183 
00184   Double_t GetDeltaScatter(Int_t idigit) { 
00185     if( idigit>=0 && idigit<fNDigits ) {
00186       return fDeltaScatter[idigit]; 
00187     }
00188     else return 0.0;
00189   }
00190 
00191   Double_t GetPointPath(Int_t idigit) { 
00192     if( idigit>=0 && idigit<fNDigits ) {
00193       return fPointPath[idigit]; 
00194     }
00195     else return 0.0;
00196   }
00197 
00198   Double_t GetExtendedPath(Int_t idigit) { 
00199     if( idigit>=0 && idigit<fNDigits ) {
00200       return fExtendedPath[idigit]; 
00201     }
00202     else return 0.0;
00203   }
00204 
00205   Double_t GetPointResidual(Int_t idigit) { 
00206     if( idigit>=0 && idigit<fNDigits ) {
00207       return fPointResidual[idigit]; 
00208     }
00209     else return 0.0;
00210   }
00211 
00212   Double_t GetExtendedResidual(Int_t idigit) { 
00213     if( idigit>=0 && idigit<fNDigits ) {
00214       return fExtendedResidual[idigit]; 
00215     }
00216     else return 0.0;
00217   }
00218 
00219   Double_t GetDelta(Int_t idigit) { 
00220     if( idigit>=0 && idigit<fNDigits ) {
00221       return fDelta[idigit]; 
00222     }
00223     else return 0.0;
00224   }
00225 
00226   Double_t GetDeltaCorrection(Int_t idigit, Double_t length);
00227 
00228   UInt_t GetNSeeds() {
00229     return vSeedVtxX.size();
00230   }
00231 
00232   Double_t GetSeedVtxX(UInt_t ivtx) {
00233     if( ivtx>=0 && ivtx<GetNSeeds() ){
00234       return vSeedVtxX.at(ivtx);
00235     }
00236     else return 0.0;
00237   }
00238 
00239   Double_t GetSeedVtxY(UInt_t ivtx) {
00240     if( ivtx>=0 && ivtx<GetNSeeds() ){
00241       return vSeedVtxY.at(ivtx);
00242     }
00243     else return 0.0;
00244   }
00245 
00246   Double_t GetSeedVtxZ(UInt_t ivtx) {
00247     if( ivtx>=0 && ivtx<GetNSeeds() ){
00248       return vSeedVtxZ.at(ivtx);
00249     }
00250     else return 0.0;
00251   } 
00252 
00253   Double_t GetSeedVtxTime(UInt_t ivtx) {
00254     if( ivtx>=0 && ivtx<GetNSeeds() ){
00255       return vSeedVtxTime.at(ivtx);
00256     }
00257     else return 0.0;
00258   }
00259 
00260  private:
00261   WCSimVertexGeometry();
00262   ~WCSimVertexGeometry();
00263 
00264   void CalcSimpleVertex(Double_t& vtxX, Double_t& vtxY, Double_t& vtxZ, 
00265                         Double_t& vtxTime);
00266 
00267   void ChooseNextQuadruple(Double_t& x0, Double_t& y0, Double_t& z0, Double_t& t0,
00268                            Double_t& x1, Double_t& y1, Double_t& z1, Double_t& t1,
00269                            Double_t& x2, Double_t& y2, Double_t& z2, Double_t& t2,
00270                            Double_t& x3, Double_t& y3, Double_t& z3, Double_t& t3);
00271 
00272   void ChooseNextDigit(Double_t& x, Double_t& y, Double_t& z, Double_t& t);
00273 
00274   Int_t fRunNum;
00275   Int_t fEventNum;
00276   Int_t fTriggerNum;
00277 
00278   Int_t fPMTs;
00279   Int_t fNDigits;
00280   Int_t fNFilterDigits;
00281 
00282   Int_t fThisDigit;
00283   Int_t fLastEntry;
00284   Int_t fCounter;
00285 
00286   Double_t fVtxX1;
00287   Double_t fVtxY1;
00288   Double_t fVtxZ1;
00289   Double_t fVtxTime1;
00290 
00291   Double_t fVtxX2;
00292   Double_t fVtxY2;
00293   Double_t fVtxZ2;
00294   Double_t fVtxTime2;
00295 
00296   Double_t fMeanQ;
00297   Double_t fTotalQ; 
00298 
00299   Double_t fMeanFilteredQ;
00300   Double_t fTotalFilteredQ;
00301 
00302   Double_t fMinTime;
00303   Double_t fMaxTime;
00304 
00305   Bool_t* fIsFiltered; 
00306 
00307   Double_t* fDigitX;           // Digit X (cm)
00308   Double_t* fDigitY;           // Digit Y (cm)
00309   Double_t* fDigitZ;           // Digit Z (cm)
00310   Double_t* fDigitT;           // Digit T (ns)
00311   Double_t* fDigitQ;           // Digit Q (PEs)
00312 
00313   Double_t* fZenith;           // Zenith (degrees)
00314   Double_t* fAzimuth;          // Azimuth (degrees)
00315   Double_t* fSolidAngle;       // SolidAngle = sin(angle)/sin(42)
00316   Double_t* fConeAngle;        // Cone Angle (degrees)
00317 
00318   Double_t* fDistPoint;        // Distance from Vertex (S)
00319   Double_t* fDistTrack;        // Distance along Track (S1)
00320   Double_t* fDistPhoton;       // Distance along Photon (S2)
00321   Double_t* fDistScatter;      // Distance of Scattering 
00322 
00323   Double_t* fDeltaTime;        // DeltaT = T - VtxT
00324   Double_t* fDeltaSigma;       // SigmaT(Q)
00325 
00326   Double_t* fDeltaAngle;       // DeltaAngle  = ConeAngle - Angle
00327   Double_t* fDeltaPoint;       // DeltaPoint  = DistPoint/(fC/fN)
00328   Double_t* fDeltaTrack;       // DeltaTrack  = DistTrack/(fC)
00329   Double_t* fDeltaPhoton;      // DeltaPhoton = DistPhoton/(fC/fN)
00330   Double_t* fDeltaScatter;     // DeltaScatter = DeltaScatter/(fC/fN)
00331 
00332   Double_t* fPointPath;        // PointPath = fN*DistPoint
00333   Double_t* fExtendedPath;     // ExtendedPath = DistTrack + fN*DistPhoton
00334 
00335   Double_t* fPointResidual;    // PointResidual = DeltaTime - PointPath
00336   Double_t* fExtendedResidual; // ExtendedResidual = DeltaTime - ExtendedPath
00337   Double_t* fDelta;            // Chosen Residual [Point/Extended/Null]
00338 
00339 
00340   std::vector<Double_t> vSeedVtxX;         
00341   std::vector<Double_t> vSeedVtxY;
00342   std::vector<Double_t> vSeedVtxZ;
00343   std::vector<Double_t> vSeedVtxTime;
00344   std::vector<Int_t> vSeedDigitList;
00345 
00346   std::vector<WCSimRecoVertex*> vVertexList;
00347 
00348   ClassDef(WCSimVertexGeometry,0)
00349 
00350 };
00351 
00352 #endif