StRoot: StHighptPool/StHiMicroAnalysis/StHiStuff.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StHiStuff.cxx,v 1.5 2004/01/26 22:59:41 perev Exp $
00004  *
00005  * Author: Bum Choi, UT Austin, Apr 2002
00006  *
00007  ***************************************************************************
00008  *
00009  * Description:  Class for making highpt Analysis histograms from highpt
00010  *               uDST's
00011  *
00012  ***************************************************************************
00013  *
00014  * $Log: StHiStuff.cxx,v $
00015  * Revision 1.5  2004/01/26 22:59:41  perev
00016  * Add init of statick member
00017  *
00018  * Revision 1.4  2003/04/30 20:37:30  perev
00019  * Warnings cleanup. Modified lines marked VP
00020  *
00021  * Revision 1.3  2002/05/31 21:58:30  jklay
00022  * Updated analysis code to use new cut class
00023  *
00024  * Revision 1.2  2002/04/03 00:23:27  jklay
00025  * Fixed private member access bugs in analysis code
00026  *
00027  * Revision 1.1  2002/04/02 20:05:18  jklay
00028  * Bums analysis tools for highpt uDSTs
00029  *
00030  *
00031  **************************************************************************/
00032 #include "StHiStuff.h"
00033 Float_t StHiStuff::mMinPt = 2.5;
00034 
00035 //__________________
00036 
00037 StHiStuff::StHiStuff(const char* inputDir,
00038                            const char* outRootName)
00039   :  StHiBaseAnalysis(inputDir,outRootName)
00040      
00041 {
00042 
00043 
00044 }
00045 
00046 //__________________
00047 
00048 StHiStuff::~StHiStuff()
00049 {
00050 }
00051 
00052 //_____________________________
00053 
00054 Int_t 
00055 StHiStuff::initMore()
00056 {
00057  
00058   return 0;
00059  
00060 }
00061 
00062 
00063 //_____________________________
00064 
00065 void
00066 StHiStuff::initHistograms()
00067 {
00068   cout << "StHiStuff::initHistograms()" << endl;
00069   
00070   char name[100];
00071 
00072   //***********************
00073   
00074   using namespace Bin;
00075 
00076   //***********************
00077 
00078   TString sEW[3] = {"East","West","FullTPC"};
00079   TString sPM[3] = {"Plus","Minus","Charged"};
00080 
00081   // positive, negative
00082   for(int iew=0; iew<3; iew++) {
00083     for(int ipm=0; ipm<3; ipm++){
00084     
00085       setName(name,"h3PhiGlDcaXYGlVertexZ",sEW[iew].Data(),sPM[ipm].Data());
00086       ew[iew].pm[ipm].h3PhiGlDcaXYGlVertexZ
00087         = new TH3D(name,name,
00088                  nPhiBin,phiDegMin,phiDegMax,
00089                  nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00090                  nMidZBigBin,midZBigMin,midZBigMax);
00091       ew[iew].pm[ipm].h3PhiGlDcaXYGlVertexZ->Sumw2();
00092 
00093       setName(name,"h3PhiPrDcaXYGlVertexZ",sEW[iew].Data(),sPM[ipm].Data());
00094       ew[iew].pm[ipm].h3PhiPrDcaXYGlVertexZ
00095         = new TH3D(name,name,
00096                  nPhiBin,phiDegMin,phiDegMax,
00097                  nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00098                  nMidZBigBin,midZBigMin,midZBigMax);
00099       ew[iew].pm[ipm].h3PhiPrDcaXYGlVertexZ->Sumw2();
00100 
00101       setName(name,"h1PhiGlReality",sEW[iew].Data(),sPM[ipm].Data());
00102       ew[iew].pm[ipm].h1PhiGlReality
00103         = new TH1D(name,name,
00104                  nPhiBin,phiMin,phiMax);
00105       ew[iew].pm[ipm].h1PhiGlReality->Sumw2();
00106     
00107     
00108       setName(name,"h3PhiPrDcaXYGlPtPr",sEW[iew].Data(),sPM[ipm].Data());
00109       ew[iew].pm[ipm].h3PhiPrDcaXYGlPtPr
00110         = new TH3D(name,name,
00111                  nPhiBin,phiDegMin,phiDegMax,
00112                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00113                  nPtBin,ptMin,ptMax);
00114       ew[iew].pm[ipm].h3PhiPrDcaXYGlPtPr->Sumw2();
00115     
00116       setName(name,"h3PhiGlDcaXYGlPtGl",sEW[iew].Data(),sPM[ipm].Data());
00117       ew[iew].pm[ipm].h3PhiGlDcaXYGlPtGl
00118         = new TH3D(name,name,
00119                  nPhiBin,phiDegMin,phiDegMax,
00120                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00121                  nPtBin,ptMin,ptMax);
00122       ew[iew].pm[ipm].h3PhiGlDcaXYGlPtGl->Sumw2();
00123         
00124       setName(name,"h3SectorDcaXYGlPtPr",sEW[iew].Data(),sPM[ipm].Data());
00125       ew[iew].pm[ipm].h3SectorDcaXYGlPtPr
00126         = new TH3D(name,name,
00127                  nSectorBin,sectorMin,sectorMax,
00128                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00129                  nPtBin,ptMin,ptMax);
00130       ew[iew].pm[ipm].h3SectorDcaXYGlPtPr->Sumw2();
00131     
00132       setName(name,"h3SectorDcaXYGlPtGl",sEW[iew].Data(),sPM[ipm].Data());
00133       ew[iew].pm[ipm].h3SectorDcaXYGlPtGl
00134         = new TH3D(name,name,
00135                  nSectorBin,sectorMin,sectorMax,
00136                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00137                  nPtBin,ptMin,ptMax);
00138       ew[iew].pm[ipm].h3SectorDcaXYGlPtGl->Sumw2();
00139 
00140       setName(name,"h3SectorVertexZPtPr",sEW[iew].Data(),sPM[ipm].Data());
00141       ew[iew].pm[ipm].h3SectorVertexZPtPr
00142         = new TH3D(name,name,
00143                  nSectorBin,sectorMin,sectorMax,
00144                  nAbsZBigBin,absZBigMin,absZBigMax,
00145                  nPtBin,ptMin,ptMax);
00146       ew[iew].pm[ipm].h3SectorVertexZPtPr->Sumw2();
00147     
00148       setName(name,"h3SectorVertexZPtGl",sEW[iew].Data(),sPM[ipm].Data());
00149       ew[iew].pm[ipm].h3SectorVertexZPtGl
00150         = new TH3D(name,name,
00151                  nPhiBin,sectorMin,sectorMax,
00152                  nAbsZBigBin,absZBigMin,absZBigMax,
00153                  nPtBin,ptMin,ptMax);
00154       ew[iew].pm[ipm].h3SectorVertexZPtGl->Sumw2();
00155 
00156       setName(name,"h3PhiPrVertexZPtPr",sEW[iew].Data(),sPM[ipm].Data());
00157       ew[iew].pm[ipm].h3PhiPrVertexZPtPr
00158         = new TH3D(name,name,
00159                  nSectorBin,phiMin,phiMax,
00160                  nAbsZBigBin,absZBigMin,absZBigMax,
00161                  nPtBin,ptMin,ptMax);
00162       ew[iew].pm[ipm].h3PhiPrVertexZPtPr->Sumw2();
00163     
00164       setName(name,"h3PhiGlVertexZPtGl",sEW[iew].Data(),sPM[ipm].Data());
00165       ew[iew].pm[ipm].h3PhiGlVertexZPtGl
00166         = new TH3D(name,name,
00167                  nPhiBin,phiMin,phiMax,
00168                  nAbsZBigBin,absZBigMin,absZBigMax,
00169                  nPtBin,ptMin,ptMax);
00170       ew[iew].pm[ipm].h3PhiGlVertexZPtGl->Sumw2();
00171 
00172       setName(name,"h3PhiPrEtaPrMidZ",sEW[iew].Data(),sPM[ipm].Data());
00173       ew[iew].pm[ipm].h3PhiPrEtaPrMidZ
00174         = new TH3D(name,name,
00175                  nPhiBin,phiMin,phiMax,
00176                  nEtaBigBin,etaBigMin,etaBigMax,
00177                  nMidZBigBin,midZBigMin,midZBigMax);
00178       ew[iew].pm[ipm].h3PhiPrEtaPrMidZ->Sumw2();
00179     
00180       setName(name,"h3PhiGlEtaPrMidZ",sEW[iew].Data(),sPM[ipm].Data());
00181       ew[iew].pm[ipm].h3PhiGlEtaPrMidZ
00182         = new TH3D(name,name,
00183                  nPhiBin,phiMin,phiMax,
00184                  nEtaBigBin,etaBigMin,etaBigMax,
00185                    nMidZBigBin,midZBigMin,midZBigMax);
00186       ew[iew].pm[ipm].h3PhiGlEtaPrMidZ->Sumw2();
00187     
00188       setName(name,"h1PhiPrHighPtCut",sEW[iew].Data(),sPM[ipm].Data());
00189       ew[iew].pm[ipm].h1PhiPrHighPtCut
00190         = new TH1D(name,name,nPhiBin,phiMin,phiMax);
00191       ew[iew].pm[ipm].h1PhiPrHighPtCut->Sumw2();
00192     
00193       setName(name,"h1PhiPrLowPtCut",sEW[iew].Data(),sPM[ipm].Data());
00194       ew[iew].pm[ipm].h1PhiPrLowPtCut
00195         = new TH1D(name,name,nPhiBin,phiMin,phiMax);
00196       ew[iew].pm[ipm].h1PhiPrLowPtCut->Sumw2();
00197     
00198       setName(name,"h3PhiPrNFitHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00199       ew[iew].pm[ipm].h3PhiPrNFitHitPtPr
00200         = new TH3D(name,name,
00201                  nPhiBin,phiMin,phiMax,
00202                  nFitHitThinBin,fitHitThinMin,fitHitThinMax,
00203                  nPtBin,ptMin,ptMax);
00204       ew[iew].pm[ipm].h3PhiPrNFitHitPtPr->Sumw2();
00205     
00206       setName(name,"h3PhiPrNAllHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00207       ew[iew].pm[ipm].h3PhiPrNAllHitPtPr
00208         = new TH3D(name,name,
00209                  nPhiBin,phiMin,phiMax,
00210                  nFitHitThinBin,fitHitThinMin,fitHitThinMax,
00211                  nPtBin,ptMin,ptMax);
00212       ew[iew].pm[ipm].h3PhiPrNAllHitPtPr->Sumw2();
00213 
00214       setName(name,"h3PhiPrFracHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00215       ew[iew].pm[ipm].h3PhiPrFracHitPtPr
00216         = new TH3D(name,name,
00217                  nPhiBin,phiMin,phiMax,
00218                  nFracHitBin,fracHitMin,fracHitMax,
00219                  nPtBin,ptMin,ptMax);
00220       ew[iew].pm[ipm].h3PhiPrFracHitPtPr->Sumw2();
00221 
00222       setName(name,"h3PhiPrSmallNFitHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00223       ew[iew].pm[ipm].h3PhiPrSmallNFitHitPtPr
00224         = new TH3D(name,name,
00225                  nPhiSmallBin,phiMin,phiMax,
00226                  nFitHitThinBin,fitHitThinMin,fitHitThinMax,
00227                  nPtBin,ptMin,ptMax);
00228       ew[iew].pm[ipm].h3PhiPrSmallNFitHitPtPr->Sumw2();
00229     
00230       setName(name,"h3PhiPrSmallNAllHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00231       ew[iew].pm[ipm].h3PhiPrSmallNAllHitPtPr
00232         = new TH3D(name,name,
00233                  nPhiSmallBin,phiMin,phiMax,
00234                  nFitHitThinBin,fitHitThinMin,fitHitThinMax,
00235                  nPtBin,ptMin,ptMax);
00236       ew[iew].pm[ipm].h3PhiPrSmallNAllHitPtPr->Sumw2();
00237 
00238       setName(name,"h3PhiPrSmallFracHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00239       ew[iew].pm[ipm].h3PhiPrSmallFracHitPtPr
00240         = new TH3D(name,name,
00241                  nPhiSmallBin,phiMin,phiMax,
00242                  nFracHitBin,fracHitMin,fracHitMax,
00243                  nPtBin,ptMin,ptMax);
00244       ew[iew].pm[ipm].h3PhiPrSmallFracHitPtPr->Sumw2();
00245 
00246 
00247       setName(name,"h3PhiGlNFitHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00248       ew[iew].pm[ipm].h3PhiGlNFitHitPtPr
00249         = new TH3D(name,name,
00250                  nPhiBin,phiMin,phiMax,
00251                  nFitHitThinBin,fitHitThinMin,fitHitThinMax,
00252                  nPtBin,ptMin,ptMax);
00253       ew[iew].pm[ipm].h3PhiGlNFitHitPtPr->Sumw2();
00254     
00255       setName(name,"h3PhiGlNAllHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00256       ew[iew].pm[ipm].h3PhiGlNAllHitPtPr
00257         = new TH3D(name,name,
00258                  nPhiBin,phiMin,phiMax,
00259                  nFitHitThinBin,fitHitThinMin,fitHitThinMax,
00260                  nPtBin,ptMin,ptMax);
00261       ew[iew].pm[ipm].h3PhiGlNAllHitPtPr->Sumw2();
00262     
00263       setName(name,"h3PhiGlFracHitPtPr",sEW[iew].Data(),sPM[ipm].Data());
00264       ew[iew].pm[ipm].h3PhiGlFracHitPtPr
00265         = new TH3D(name,name,
00266                  nPhiBin,phiMin,phiMax,
00267                  nFracHitBin,fracHitMin,fracHitMax,
00268                  nPtBin,ptMin,ptMax);
00269       ew[iew].pm[ipm].h3PhiGlFracHitPtPr->Sumw2();
00270     
00271       // analysis cut
00272       setName(name,"h3VtxZEtaPrPtPrCut",sEW[iew].Data(),sPM[ipm].Data());
00273       ew[iew].pm[ipm].h3VtxZEtaPrPtPrCut
00274         = new TH3D(name,name,
00275                  nVertexZBin,vertexZMin,vertexZMax,
00276                  nEtaSmallBin,etaSmallMin,etaSmallMax,
00277                  nPtBin,ptMin,ptMax);
00278     
00279       setName(name,"h3VtxZEtaGlPtGlCut",sEW[iew].Data(),sPM[ipm].Data());
00280       ew[iew].pm[ipm].h3VtxZEtaGlPtGlCut
00281         = new TH3D(name,name,
00282                  nVertexZBin,vertexZMin,vertexZMax,
00283                  nEtaSmallBin,etaSmallMin,etaSmallMax,
00284                  nPtBin,ptMin,ptMax);
00285 
00286       setName(name,"h3ResPtDcaXYGlPtGlEastCut",sEW[iew].Data(),sPM[ipm].Data());
00287       ew[iew].pm[ipm].h3ResPtDcaXYGlPtGlEastCut
00288         = new TH3D(name,name,
00289                  nResPtBin,resPtMin,resPtMax,
00290                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00291                  nPtBin,ptMin,ptMax);
00292 
00293       setName(name,"h3ResPtDcaXYGlPtGlWestCut",sEW[iew].Data(),sPM[ipm].Data());
00294       ew[iew].pm[ipm].h3ResPtDcaXYGlPtGlWestCut
00295         = new TH3D(name,name,
00296                  nResPtBin,resPtMin,resPtMax,
00297                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00298                  nPtBin,ptMin,ptMax);
00299 
00300       setName(name,"h3ResPtDcaXYGlPtPrEastCut",sEW[iew].Data(),sPM[ipm].Data());
00301       ew[iew].pm[ipm].h3ResPtDcaXYGlPtPrEastCut
00302         = new TH3D(name,name,
00303                  nResPtBin,resPtMin,resPtMax,
00304                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00305                  nPtBin,ptMin,ptMax);
00306 
00307       setName(name,"h3ResPtDcaXYGlPtPrWestCut",sEW[iew].Data(),sPM[ipm].Data());
00308       ew[iew].pm[ipm].h3ResPtDcaXYGlPtPrWestCut
00309         = new TH3D(name,name,
00310                  nResPtBin,resPtMin,resPtMax,
00311                  nDcaXYGlWideBin,dcaXYGlMin,dcaXYGlMax,
00312                  nPtBin,ptMin,ptMax);
00313 
00314       setName(name,"h3PhiGlPtPrPtGlEastCut",sEW[iew].Data(),sPM[ipm].Data());
00315       ew[iew].pm[ipm].h3PhiGlPtPrPtGlEastCut
00316         = new TH3D(name,name,
00317                  nPhiBin,phiDegMin,phiDegMax,
00318                  nPtBin,ptMin,ptMax,
00319                  nPtBin,ptMin,ptMax);
00320     
00321       setName(name,"h3PhiGlPtPrPtGlWestCut",sEW[iew].Data(),sPM[ipm].Data());
00322       ew[iew].pm[ipm].h3PhiGlPtPrPtGlWestCut
00323         = new TH3D(name,name,
00324                  nPhiBin,phiDegMin,phiDegMax,
00325                  nPtBin,ptMin,ptMax,
00326                  nPtBin,ptMin,ptMax);
00327     
00328       setName(name,"h2VtxZLastZ",sEW[iew].Data(),sPM[ipm].Data());
00329       ew[iew].pm[ipm].h2VtxZLastZ
00330         = new TH2D(name,name,
00331                  nVertexZBin,vertexZMin,vertexZMax,
00332                  nVertexZBin,vertexZMin,vertexZMax);
00333     
00334                  
00335     }    
00336   }
00337 
00338 }
00339 
00340 //_____________________
00341 
00342 void 
00343 StHiStuff::trackLoop()
00344 {
00345   if(mDebug)
00346     cout << "StHiStuff::trackLoop()" << endl;
00347 
00348   //
00349   // event stuff
00350   // 
00351 //VPunused  Float_t zdcSum = mHiMicroEvent->ZDCe() + mHiMicroEvent->ZDCw();
00352 //VPunused  Float_t ctb    = mHiMicroEvent->CTB();
00353 //VPunused  Float_t flowCent   = mHiMicroEvent->Centrality();
00354 //  NchCentrality zdcCent = centrality(zdcSum,ctb);
00355 
00356 
00357   Int_t nTrack = mHiMicroEvent->NTrack();
00358   StHiMicroTrack* track;
00359   
00360   for(Int_t i=0; i<nTrack; i++){
00361     track =(StHiMicroTrack*) mHiMicroEvent->tracks()->At(i);
00362 
00363     Float_t vertexZ = mHiMicroEvent->VertexZ();
00364 
00365     Float_t ptPr  = track->PtPr();
00366     Float_t ptGl  = track->PtGl();
00367     Float_t etaGl = track->EtaGl();
00368     Float_t etaPr = track->EtaPr();
00369     //Float_t curvPr = track->CurvPr();
00370     //Float_t curvGl = track->CurvGl();
00371     //Float_t resPt = (ptPr-ptGl)/ptPr;
00372     //Float_t resCurvPrGl = (curvPr-curvGl)/curvPr;
00373     //Float_t resCurvGlPr = (curvGl-curvPr)/curvGl;
00374     Float_t resPtPrGlOverPr = (ptPr-ptGl)/ptPr;
00375     Float_t resPtPrGl = (ptPr-ptGl)/ptGl;
00376     Float_t fracPts = (Float_t) track->FitPts()/ (Float_t) track->AllPts();
00377     Float_t dcaXYGl = track->DcaXYGl();
00378     // Float_t dPhi = track->PhiPr() - track->PhiGl();
00379     Float_t phiPr = track->PhiPr();
00380     Float_t phiGl = track->PhiGl();
00381     //Float_t midZ = 100*TMath::Tan(track->DipAnglePr()) + vertexZ;
00382     Int_t   fitPts = track->FitPts();
00383     Int_t   allPts = track->AllPts();
00384 //VPunused    Int_t   charge = track->Charge();
00385     Float_t phiGlDeg = phiGl*180./TMath::Pi();
00386     Float_t phiPrDeg = phiPr*180./TMath::Pi();
00387     Int_t firstSector = track->FirstSector();
00388 
00389     Int_t sector = findSector(phiGl,firstSector);
00390 
00391     phiGlDeg = (phiGlDeg<-165) ? (phiGlDeg += 360) : phiGlDeg;
00392     phiPrDeg = (phiPrDeg<-165) ? (phiPrDeg += 360) : phiPrDeg;
00393 
00394     //Float_t exitZ = vtxZ+200*TMath::Tan(track->DipAnglePr());
00395 
00396     Int_t iCharge = (track->Charge()>0) ? 0 : 1; //plus is 0
00397     //This definition of iSide only requires the track be on
00398     //one half or the other and doesn't specify vertex position
00399     //Need to make that cut explicitly using the cutList
00400     Int_t iSide = (CutRc::AcceptEastSideTrack(track)) ? 0 : 1; //east is 0
00401 
00402     // ** analysis cut
00403     if(CutRc::AcceptTrackVtxZHalf(track,vertexZ)){
00404       // fit points
00405       if(CutRc::AcceptFitPts(track)){
00406         ew[iSide].pm[iCharge].h2VtxZLastZ->Fill(vertexZ,track->LastZ());
00407         ew[2].pm[2].h2VtxZLastZ->Fill(vertexZ,track->LastZ());
00408         ew[2].pm[iCharge].h2VtxZLastZ->Fill(vertexZ,track->LastZ());
00409         ew[iSide].pm[2].h2VtxZLastZ->Fill(vertexZ,track->LastZ());
00410 
00411         ew[iSide].pm[iCharge].h3VtxZEtaPrPtPrCut->Fill(vertexZ,etaPr,ptPr);
00412         ew[2].pm[2].h3VtxZEtaPrPtPrCut->Fill(vertexZ,etaPr,ptPr);
00413         ew[2].pm[iCharge].h3VtxZEtaPrPtPrCut->Fill(vertexZ,etaPr,ptPr);
00414         ew[iSide].pm[2].h3VtxZEtaPrPtPrCut->Fill(vertexZ,etaPr,ptPr);
00415 
00416         ew[iSide].pm[iCharge].h3VtxZEtaGlPtGlCut->Fill(vertexZ,etaGl,ptGl);
00417         ew[2].pm[2].h3VtxZEtaGlPtGlCut->Fill(vertexZ,etaGl,ptGl);
00418         ew[2].pm[iCharge].h3VtxZEtaGlPtGlCut->Fill(vertexZ,etaGl,ptGl);
00419         ew[iSide].pm[2].h3VtxZEtaGlPtGlCut->Fill(vertexZ,etaGl,ptGl);
00420         
00421         if(fabs(track->EtaGl())<0.7){
00422           if(track->FirstZ() < 0 ) { //east
00423             ew[iSide].pm[iCharge].h3ResPtDcaXYGlPtGlEastCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00424             ew[2].pm[2].h3ResPtDcaXYGlPtGlEastCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00425             ew[2].pm[iCharge].h3ResPtDcaXYGlPtGlEastCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00426             ew[iSide].pm[2].h3ResPtDcaXYGlPtGlEastCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00427 
00428             ew[iSide].pm[iCharge].h3ResPtDcaXYGlPtPrEastCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00429             ew[2].pm[2].h3ResPtDcaXYGlPtPrEastCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00430             ew[2].pm[iCharge].h3ResPtDcaXYGlPtPrEastCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00431             ew[iSide].pm[2].h3ResPtDcaXYGlPtPrEastCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00432             if(fabs(track->DcaXYGl())<1.2)
00433               ew[iSide].pm[iCharge].h3PhiGlPtPrPtGlEastCut->Fill(phiGlDeg,ptPr,ptGl);
00434               ew[2].pm[2].h3PhiGlPtPrPtGlEastCut->Fill(phiGlDeg,ptPr,ptGl);
00435               ew[2].pm[iCharge].h3PhiGlPtPrPtGlEastCut->Fill(phiGlDeg,ptPr,ptGl);
00436               ew[iSide].pm[2].h3PhiGlPtPrPtGlEastCut->Fill(phiGlDeg,ptPr,ptGl);
00437           }
00438           else{
00439             ew[iSide].pm[iCharge].h3ResPtDcaXYGlPtGlWestCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00440             ew[2].pm[2].h3ResPtDcaXYGlPtGlWestCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00441             ew[2].pm[iCharge].h3ResPtDcaXYGlPtGlWestCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00442             ew[iSide].pm[2].h3ResPtDcaXYGlPtGlWestCut->Fill(resPtPrGl,dcaXYGl,ptGl);
00443 
00444             ew[iSide].pm[iCharge].h3ResPtDcaXYGlPtPrWestCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00445             ew[2].pm[2].h3ResPtDcaXYGlPtPrWestCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00446             ew[2].pm[iCharge].h3ResPtDcaXYGlPtPrWestCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00447             ew[iSide].pm[2].h3ResPtDcaXYGlPtPrWestCut->Fill(resPtPrGlOverPr,dcaXYGl,ptPr);
00448             if(fabs(track->DcaXYGl())<1.2)
00449               ew[iSide].pm[iCharge].h3PhiGlPtPrPtGlWestCut->Fill(phiGlDeg,ptPr,ptGl);
00450               ew[2].pm[2].h3PhiGlPtPrPtGlWestCut->Fill(phiGlDeg,ptPr,ptGl);
00451               ew[2].pm[iCharge].h3PhiGlPtPrPtGlWestCut->Fill(phiGlDeg,ptPr,ptGl);
00452               ew[iSide].pm[2].h3PhiGlPtPrPtGlWestCut->Fill(phiGlDeg,ptPr,ptGl);
00453           }
00454         }
00455       }
00456     }
00457 
00458     //************ plus/minus
00459     //***eta 
00460     //
00461     if(CutRc::AcceptEta(track)){
00462       
00463       //
00464       // reality check
00465       //
00466       //if(fabs(etaPr)>.5) cout << "huh?" << endl;
00467 
00468       // eta and fit pts
00469       //
00470       if(CutRc::AcceptFitPts(track)){
00471         ew[iSide].pm[iCharge].h3PhiPrDcaXYGlPtPr->Fill(phiPrDeg,dcaXYGl,ptPr);
00472         ew[2].pm[2].h3PhiPrDcaXYGlPtPr->Fill(phiPrDeg,dcaXYGl,ptPr);
00473         ew[2].pm[iCharge].h3PhiPrDcaXYGlPtPr->Fill(phiPrDeg,dcaXYGl,ptPr);
00474         ew[iSide].pm[2].h3PhiPrDcaXYGlPtPr->Fill(phiPrDeg,dcaXYGl,ptPr);
00475 
00476         ew[iSide].pm[iCharge].h3PhiGlDcaXYGlPtGl->Fill(phiGlDeg,dcaXYGl,ptGl);
00477         ew[2].pm[2].h3PhiGlDcaXYGlPtGl->Fill(phiGlDeg,dcaXYGl,ptGl);
00478         ew[2].pm[iCharge].h3PhiGlDcaXYGlPtGl->Fill(phiGlDeg,dcaXYGl,ptGl);
00479         ew[iSide].pm[2].h3PhiGlDcaXYGlPtGl->Fill(phiGlDeg,dcaXYGl,ptGl);
00480 
00481         ew[iSide].pm[iCharge].h3SectorDcaXYGlPtPr->Fill(sector,dcaXYGl,ptPr);
00482         ew[2].pm[2].h3SectorDcaXYGlPtPr->Fill(sector,dcaXYGl,ptPr);
00483         ew[2].pm[iCharge].h3SectorDcaXYGlPtPr->Fill(sector,dcaXYGl,ptPr);
00484         ew[iSide].pm[2].h3SectorDcaXYGlPtPr->Fill(sector,dcaXYGl,ptPr);
00485 
00486         ew[iSide].pm[iCharge].h3SectorDcaXYGlPtGl->Fill(sector,dcaXYGl,ptGl);
00487         ew[2].pm[2].h3SectorDcaXYGlPtGl->Fill(sector,dcaXYGl,ptGl);
00488         ew[2].pm[iCharge].h3SectorDcaXYGlPtGl->Fill(sector,dcaXYGl,ptGl);
00489         ew[iSide].pm[2].h3SectorDcaXYGlPtGl->Fill(sector,dcaXYGl,ptGl);
00490         
00491       }
00492 
00493       // eta, sdca, and fitpts
00494       //
00495       if(CutRc::AcceptSDcaGl(track) && CutRc::AcceptFitPts(track)){
00496         ew[iSide].pm[iCharge].h3PhiPrNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00497         ew[2].pm[2].h3PhiPrNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00498         ew[2].pm[iCharge].h3PhiPrNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00499         ew[iSide].pm[2].h3PhiPrNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00500 
00501         ew[iSide].pm[iCharge].h3PhiPrSmallNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00502         ew[2].pm[2].h3PhiPrSmallNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00503         ew[2].pm[iCharge].h3PhiPrSmallNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00504         ew[iSide].pm[2].h3PhiPrSmallNFitHitPtPr->Fill(phiPr,fitPts,ptPr);
00505 
00506         ew[iSide].pm[iCharge].h3PhiGlNFitHitPtPr->Fill(phiGl,fitPts,ptPr);
00507         ew[2].pm[2].h3PhiGlNFitHitPtPr->Fill(phiGl,fitPts,ptPr);
00508         ew[2].pm[iCharge].h3PhiGlNFitHitPtPr->Fill(phiGl,fitPts,ptPr);
00509         ew[iSide].pm[2].h3PhiGlNFitHitPtPr->Fill(phiGl,fitPts,ptPr);
00510 
00511         ew[iSide].pm[iCharge].h3PhiPrNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00512         ew[2].pm[2].h3PhiPrNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00513         ew[2].pm[iCharge].h3PhiPrNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00514         ew[iSide].pm[2].h3PhiPrNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00515 
00516         ew[iSide].pm[iCharge].h3PhiPrSmallNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00517         ew[2].pm[2].h3PhiPrSmallNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00518         ew[2].pm[iCharge].h3PhiPrSmallNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00519         ew[iSide].pm[2].h3PhiPrSmallNAllHitPtPr->Fill(phiPr,allPts,ptPr);
00520 
00521         ew[iSide].pm[iCharge].h3PhiGlNAllHitPtPr->Fill(phiGl,allPts,ptPr);
00522         ew[2].pm[2].h3PhiGlNAllHitPtPr->Fill(phiGl,allPts,ptPr);
00523         ew[2].pm[iCharge].h3PhiGlNAllHitPtPr->Fill(phiGl,allPts,ptPr);
00524         ew[iSide].pm[2].h3PhiGlNAllHitPtPr->Fill(phiGl,allPts,ptPr);
00525 
00526         ew[iSide].pm[iCharge].h3PhiPrFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00527         ew[2].pm[2].h3PhiPrFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00528         ew[2].pm[iCharge].h3PhiPrFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00529         ew[iSide].pm[2].h3PhiPrFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00530 
00531         ew[iSide].pm[iCharge].h3PhiPrSmallFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00532         ew[2].pm[2].h3PhiPrSmallFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00533         ew[2].pm[iCharge].h3PhiPrSmallFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00534         ew[iSide].pm[2].h3PhiPrSmallFracHitPtPr->Fill(phiPr,fracPts,ptPr);
00535 
00536         ew[iSide].pm[iCharge].h3PhiGlFracHitPtPr->Fill(phiGl,fracPts,ptPr);
00537         ew[2].pm[2].h3PhiGlFracHitPtPr->Fill(phiGl,fracPts,ptPr);
00538         ew[2].pm[iCharge].h3PhiGlFracHitPtPr->Fill(phiGl,fracPts,ptPr);
00539         ew[iSide].pm[2].h3PhiGlFracHitPtPr->Fill(phiGl,fracPts,ptPr);
00540 
00541         // reality check
00542         if(ptPr>2 && ptPr<6){
00543           ew[iSide].pm[iCharge].h1PhiPrHighPtCut->Fill(phiPr);    
00544           ew[2].pm[2].h1PhiPrHighPtCut->Fill(phiPr);      
00545           ew[2].pm[iCharge].h1PhiPrHighPtCut->Fill(phiPr);        
00546           ew[iSide].pm[2].h1PhiPrHighPtCut->Fill(phiPr);          
00547         }
00548         if(ptPr>1 && ptPr<2){
00549           ew[iSide].pm[iCharge].h1PhiPrLowPtCut->Fill(phiPr);
00550           ew[2].pm[2].h1PhiPrLowPtCut->Fill(phiPr);
00551           ew[2].pm[iCharge].h1PhiPrLowPtCut->Fill(phiPr);
00552           ew[iSide].pm[2].h1PhiPrLowPtCut->Fill(phiPr);
00553         }
00554       }
00555 
00556     }
00557 
00558     // sdca, fitpts, tight eta
00559     
00560     if(CutRc::AcceptSDcaGl(track) && CutRc::AcceptFitPts(track) &&
00561        fabs(etaPr)<.1){
00562       ew[iSide].pm[iCharge].h3PhiPrVertexZPtPr->Fill(phiPr,fabs(vertexZ),ptPr);
00563       ew[2].pm[2].h3PhiPrVertexZPtPr->Fill(phiPr,fabs(vertexZ),ptPr);
00564       ew[2].pm[iCharge].h3PhiPrVertexZPtPr->Fill(phiPr,fabs(vertexZ),ptPr);
00565       ew[iSide].pm[2].h3PhiPrVertexZPtPr->Fill(phiPr,fabs(vertexZ),ptPr);
00566 
00567       ew[iSide].pm[iCharge].h3PhiGlVertexZPtGl->Fill(phiGl,fabs(vertexZ),ptGl);
00568       ew[2].pm[2].h3PhiGlVertexZPtGl->Fill(phiGl,fabs(vertexZ),ptGl);
00569       ew[2].pm[iCharge].h3PhiGlVertexZPtGl->Fill(phiGl,fabs(vertexZ),ptGl);
00570       ew[iSide].pm[2].h3PhiGlVertexZPtGl->Fill(phiGl,fabs(vertexZ),ptGl);
00571 
00572         ew[iSide].pm[iCharge].h3SectorVertexZPtPr->Fill(sector,fabs(vertexZ),ptPr);
00573         ew[2].pm[2].h3SectorVertexZPtPr->Fill(sector,fabs(vertexZ),ptPr);
00574         ew[2].pm[iCharge].h3SectorVertexZPtPr->Fill(sector,fabs(vertexZ),ptPr);
00575         ew[iSide].pm[2].h3SectorVertexZPtPr->Fill(sector,fabs(vertexZ),ptPr);
00576 
00577         ew[iSide].pm[iCharge].h3SectorVertexZPtGl->Fill(sector,fabs(vertexZ),ptGl);
00578         ew[2].pm[2].h3SectorVertexZPtGl->Fill(sector,fabs(vertexZ),ptGl);
00579         ew[2].pm[iCharge].h3SectorVertexZPtGl->Fill(sector,fabs(vertexZ),ptGl);
00580         ew[iSide].pm[2].h3SectorVertexZPtGl->Fill(sector,fabs(vertexZ),ptGl);
00581 
00582 
00583     }
00584 
00585     // fit pts, tight eta, pt
00586     if(CutRc::AcceptFitPts(track) && fabs(etaPr)<0.1 &&
00587        fabs(track->DcaGl())<3){
00588       if(ptGl>1.5 && ptGl<6)
00589         ew[iSide].pm[iCharge].h3PhiGlDcaXYGlVertexZ->Fill(phiGlDeg,dcaXYGl,vertexZ);
00590         ew[2].pm[2].h3PhiGlDcaXYGlVertexZ->Fill(phiGlDeg,dcaXYGl,vertexZ);
00591         ew[2].pm[iCharge].h3PhiGlDcaXYGlVertexZ->Fill(phiGlDeg,dcaXYGl,vertexZ);
00592         ew[iSide].pm[2].h3PhiGlDcaXYGlVertexZ->Fill(phiGlDeg,dcaXYGl,vertexZ);
00593       if(ptPr>1.5 && ptPr<6)
00594         ew[iSide].pm[iCharge].h3PhiPrDcaXYGlVertexZ->Fill(phiPrDeg,dcaXYGl,vertexZ);
00595         ew[2].pm[2].h3PhiPrDcaXYGlVertexZ->Fill(phiPrDeg,dcaXYGl,vertexZ);
00596         ew[2].pm[iCharge].h3PhiPrDcaXYGlVertexZ->Fill(phiPrDeg,dcaXYGl,vertexZ);
00597         ew[iSide].pm[2].h3PhiPrDcaXYGlVertexZ->Fill(phiPrDeg,dcaXYGl,vertexZ);
00598     }
00599     
00600   } // tracks
00601 
00602   if(mDebug)
00603     cout << "\ttracks : " << nTrack << endl;
00604 
00605 }
00606 //_____________________
00607 
00608 void
00609 StHiStuff::fillEventHistograms()
00610 {
00611 
00612 }
00613 
00614 //______________________
00615 
00616 void
00617 StHiStuff::finishHistograms()
00618 {
00619 
00620 }
00621 
00622 //_______________________
00623 
00624 Bool_t
00625 StHiStuff::acceptEvent(StHiMicroEvent* event)
00626 {
00627   return CutRc::Accept(event);
00628 
00629 }
00630 
00631 
00632 
00633 //_______________________
00634 
00635 // ew: east is 0, west is 1
00636 
00637 Int_t
00638 StHiStuff::findSector(Float_t phi, Int_t firstSector)
00639 {
00640   Int_t sector=0;
00641   Float_t pi = (Float_t) TMath::Pi();
00642   Float_t sectorWidth = pi/6.;
00643 
00644   Int_t sectorWest[] = {8,7,6,5,4,3,2,1,12,11,10};
00645   Int_t sectorEast[] = {16,17,18,19,20,21,22,23,24,13,14};
00646   
00647   if(phi>=(pi-sectorWidth/2.) || phi < (-pi+sectorWidth/2.)){
00648     if(firstSector <= 12 ){
00649       sector = 9;
00650     }
00651     else if(firstSector >= 13){
00652       sector = 15;
00653     }
00654     else{
00655       cerr << "wrong CutRc::Half " << ew << endl;
00656       exit(1);
00657     }
00658   }
00659   else{
00660     for(int i=0; i<11; i++){
00661       if(phi>=(-pi +sectorWidth*(i+1) - sectorWidth/2.) && 
00662          phi<(-pi +sectorWidth*(i+1) + sectorWidth/2.)){
00663         
00664         if(firstSector >= 13) sector = sectorWest[i];
00665         else if(firstSector <= 12) sector = sectorEast[i];
00666         
00667         break;
00668       }
00669     }
00670   }
00671   //  if(gRandom->Rndm()<.1)
00672   //   cout << "phi : " << phi*180./pi << " sector : " << sector << endl;
00673 
00674 
00675   if(!sector){
00676     cerr << "Huh? phi = " << phi << endl; exit(1);
00677   }
00678 
00679   return sector;
00680 }
00681 
00682 //_____________________________________
00683 
00684 ClassImp(StHiStuff)