StRoot: StHighptPool/StHiMicroAnalysis/StHiAnalysis.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StHiAnalysis.cxx,v 1.7 2002/06/13 01:14:25 jklay Exp $                                    
00004  *
00005  * Author: Bum Choi, UT Austin, Apr 2002
00006  *
00007  ***************************************************************************
00008  *
00009  * Description:  Class to perform highpt Analysis on highpt uDSTs
00010  *
00011  *
00012  ***************************************************************************
00013  *
00014  * $Log: StHiAnalysis.cxx,v $
00015  * Revision 1.7  2002/06/13 01:14:25  jklay
00016  * Combined Spectra histos into analysis
00017  *
00018  * Revision 1.2  2002/04/03 00:23:27  jklay
00019  * Fixed private member access bugs in analysis code
00020  *
00021  * Revision 1.1  2002/04/02 20:05:18  jklay
00022  * Bums analysis tools for highpt uDSTs
00023  *
00024  *
00025  * NOTE: Sector is now computed from Phi
00026  * 
00027  **************************************************************************/
00028 #include "StHiAnalysis.h"
00029 
00030 
00031 //__________________
00032 
00033 StHiAnalysis::StHiAnalysis(const char* inputDir,
00034                            const char* outRootName)
00035   :  StHiBaseAnalysis(inputDir,outRootName)
00036      
00037 {
00038 
00039 
00040 }
00041 
00042 //__________________
00043 
00044 StHiAnalysis::~StHiAnalysis()
00045 {
00046 }
00047 
00048 //_____________________________
00049 
00050 void
00051 StHiAnalysis::initHistograms()
00052 {
00053   cout << "StHiAnalysis::initHistograms()" << endl;
00054   
00055   //***********************
00056 
00057   using namespace Bin;
00058                              
00059   //***********************
00060   
00061   //  gStyle->SetPalette(1,0);
00062   char title[500],name[500];
00063 
00064   //********************************************************
00065   // number of events used to scale the spectra
00066       
00067   h1NEvent = new TH1D("h1NEvent","h1NEvent",1,1,2);
00068     
00069   // eta cut
00070   
00071   h1EtaCut = new TH1D("h1EtaCut","h1EtaCut",2,0,2);
00072 
00073   //**********Event Histograms
00074   h3VertexXYZ = new TH3D("h3VertexXYZ","h3VertexXYZ",nVertexXBin,vertexXMin,vertexXMax,
00075                                         nVertexXBin,vertexXMin,vertexXMax,
00076                                         nVertexZEvtThinBin,vertexZEvtMin,vertexZEvtMax);
00077   h3VertexXYZ->SetXTitle("Xvtx (cm)");  h3VertexXYZ->SetYTitle("Yvtx (cm)");  
00078   h3VertexXYZ->SetZTitle("Zvtx (cm)");  
00079 
00080   h2ZDCSumVsCTB = new TH2D("h2ZDCSumVsCTB","h2ZDCSumVsCTB",nCtbBin,ctbMin,ctbMax,nZdcBin,zdcMin,zdcMax);  
00081   h2ZDCSumVsCTB->SetYTitle("ZDCSum"); h2ZDCSumVsCTB->SetXTitle("CTB");
00082 
00083   //Event histos after event cuts...
00084   h2NGoodGlobalsVsNch = new TH2D("h2NGoodGlobalsVsNch","h2NGoodGlobalsVsNch",nNchBin,nChMin,nChMax,nNGGBin,nGGMin,nGGMax);
00085   h2NGoodGlobalsVsNch->SetXTitle("N_{ch}"); h2NGoodGlobalsVsNch->SetYTitle("N_{GoodGlobals}");
00086 
00087   h1FlowCent = new TH1D("h1FlowCent","h1FlowCent",nFlowCentBin,flowCentMin,flowCentMax);
00088   h1FlowCent->SetXTitle("Flow Centrality");
00089 
00090   //--------------------------------------------------
00091   //Track histograms
00092   //--------------------------------------------------
00093 
00094   //********************************************************
00095   // both charges
00096 
00097   strcpy(name,"h3ResPtPrGlPtPrDcaXYGl");
00098   h3ResPtPrGlPtPrDcaXYGl =
00099     new TH3D(name,name,
00100              nResPtBin,resPtMin,resPtMax,
00101              nPtBin,ptMin,ptMax,
00102              nDcaXYGlWideBin,dcaXYGlWideMin,dcaXYGlWideMax);
00103   h3ResPtPrGlPtPrDcaXYGl->SetXTitle("(Pr p_{T} - Gl p_{T})/Pr p_{T}");
00104   h3ResPtPrGlPtPrDcaXYGl->SetYTitle("Primary p_{T} (GeV/c)");
00105   h3ResPtPrGlPtPrDcaXYGl->SetZTitle("sDca_{XY}");
00106            
00107   strcpy(name,"h3ResPtPrGlPtGlDcaXYGl");
00108   h3ResPtPrGlPtGlDcaXYGl =
00109     new TH3D(name,name,
00110              nResPtBin,resPtMin,resPtMax,
00111              nPtBin,ptMin,ptMax,
00112              nDcaXYGlWideBin,dcaXYGlWideMin,dcaXYGlWideMax);
00113   h3ResPtPrGlPtGlDcaXYGl->SetXTitle("(Pr p_{T} - Gl p_{T})/Gl p_{T}");
00114   h3ResPtPrGlPtGlDcaXYGl->SetYTitle("Global p_{T} (GeV/c)");
00115   h3ResPtPrGlPtGlDcaXYGl->SetZTitle("sDca_{XY}");
00116 
00117   h1FitPts = new TH1D("h1FitPts","Fit Points",51,-0.5,50.5);
00118   h1FitPts->SetXTitle("Fit Points");  
00119 
00120   h2DcaGlVsSector = new TH2D("h2DcaGlVsSector","h2DcaGlVsSector",24,0.5,24.5,60,0,3);
00121   h2DcaGlVsSector->SetXTitle("Sector");  h2DcaGlVsSector->SetYTitle("Dca_{3d}");
00122 
00123   h2DcaXYGlVsSector = new TH2D("h2DcaXYGlVsSector","h2DcaXYGlVsSector",24,0.5,24.5,60,-3,3);
00124   h2DcaXYGlVsSector->SetXTitle("Sector");  h2DcaXYGlVsSector->SetYTitle("sDca_{XY}");
00125 
00126   h2FitPtsVsSector = new TH2D("h2FitPtsVsSector","h2FitPtsVsSector",24,0.5,24.5,51,-0.5,50.5);
00127   h2FitPtsVsSector->SetXTitle("Sector");  h2FitPtsVsSector->SetYTitle("Fit Points");
00128 
00129   h2MaxPtsVsSector = new TH2D("h2MaxPtsVsSector","h2MaxPtsVsSector",24,0.5,24.5,51,-0.5,50.5);
00130   h2MaxPtsVsSector->SetXTitle("Sector");  h2MaxPtsVsSector->SetYTitle("Max Points");
00131 
00132   h2AllPtsVsSector = new TH2D("h2AllPtsVsSector","h2AllPtsVsSector",24,0.5,24.5,51,-0.5,50.5);
00133   h2AllPtsVsSector->SetXTitle("Sector");  h2AllPtsVsSector->SetYTitle("All Points");
00134 
00135   h1YieldVsSector = new TH1D("h1YieldVsSector","h1YieldVsSector",24,0.5,24.5);
00136   h1YieldVsSector->SetXTitle("Sector"); h1YieldVsSector->SetYTitle("Raw Yield (h^{+}+h^{-})");
00137 
00138   h2PrPtVsSector = new TH2D("h2PrPtVsSector","h2PrPtVsSector",24,0.5,24.5,20,1.5,21.5);
00139   h2PrPtVsSector->SetXTitle("Sector");  h2PrPtVsSector->SetYTitle("Primary p_{T} (GeV/c)");
00140 
00141   h2GlPtVsSector = new TH2D("h2GlPtVsSector","h2GlPtVsSector",24,0.5,24.5,20,1.5,21.5);
00142   h2GlPtVsSector->SetXTitle("Sector");  h2GlPtVsSector->SetYTitle("Global p_{T} (GeV/c)");
00143 
00144   h2ResPrPtVsSector = new TH2D("h2ResPrPtVsSector","h2ResPrPtVsSector",24,0.5,24.5,60,-3,3);
00145   h2ResPrPtVsSector->SetXTitle("Sector");  h2ResPrPtVsSector->SetYTitle("(Pr p_{T} - Gl p_{T})/Pr p_{T}");
00146 
00147   h2ResGlPtVsSector = new TH2D("h2ResGlPtVsSector","h2ResGlPtVsSector",24,0.5,24.5,60,-3,3);
00148   h2ResGlPtVsSector->SetXTitle("Sector");  h2ResGlPtVsSector->SetYTitle("(Gl p_{T} - Pr p_{T})/Gl p_{T}");
00149 
00150   TString sPM[3] = { "Plus","Minus","Charged"};
00151   TString sEW[3] = { "East","West","FullTPC"};
00152 
00153   //*** init var bin 0
00154   TArrayD* bins0 = new TArrayD;
00155   initPtAry(bins0,0);
00156   //*** init var bin 0
00157   TArrayD* bins1 = new TArrayD;
00158   initPtAry(bins1,1);
00159 
00160   // east/west
00161   // plus/minus
00162 
00163   for (Int_t i=0; i < 3; i++) {
00164     for(Int_t j=0; j<3; j++){
00165 
00166     //******** centrality dependence of pt yields
00167 //    setName(title,"h2ZDCCentralityPtPr",sEW[i].Data(),sPM[j].Data());
00168 //    ew[i].pm[j].h2ZDCCentralityPtPr 
00169 //      = new TH2D(title,title,
00170 //                 nZdcCentBin,zdcCentMin,zdcCentMax,
00171 //                 nPtBin,ptMin,ptMax);
00172 //    ew[i].pm[j].h2ZDCCentralityPtPr->SetXTitle("ZDC Centrality");
00173 //    ew[i].pm[j].h2ZDCCentralityPtPr->SetXTitle("Primary p_{T} (GeV/c)");
00174 //    ew[i].pm[j].h2ZDCCentralityPtPr->Sumw2();
00175 
00176     setName(title,"h2CentralityPtPr",sEW[i].Data(),sPM[j].Data());
00177     ew[i].pm[j].h2CentralityPtPr
00178       = new TH2D(title,title,
00179                  nFlowCentBin,flowCentMin,flowCentMax,
00180                  nPtBin,ptMin,ptMax);
00181     ew[i].pm[j].h2CentralityPtPr->SetXTitle("Flow Centrality");
00182     ew[i].pm[j].h2CentralityPtPr->SetXTitle("Primary p_{T} (GeV/c)");
00183 //    ew[i].pm[j].h2CentralityPtPr->Sumw2();
00184 
00185     //******** sector and global dca xy
00186     setName(name,"h3PhiPrDcaXYGlPtPr",sEW[i].Data(),sPM[j].Data());
00187     ew[i].pm[j].h3PhiPrDcaXYGlPtPr
00188       = new TH3D(name,name,
00189                  nPhiBin,phiMin,phiMax,
00190                  nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00191                  nPtBin,ptMin,ptMax);
00192     ew[i].pm[j].h3PhiPrDcaXYGlPtPr->SetXTitle("#phi_{primary}");
00193     ew[i].pm[j].h3PhiPrDcaXYGlPtPr->SetYTitle("sDca_{XY}"); 
00194     ew[i].pm[j].h3PhiPrDcaXYGlPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00195 //    ew[i].pm[j].h3PhiPrDcaXYGlPtPr->Sumw2();
00196 
00197     setName(name,"h3PhiGlDcaXYGlPtGl",sEW[i],sPM[j].Data());
00198     ew[i].pm[j].h3PhiGlDcaXYGlPtGl
00199       = new TH3D(name,name,
00200                  nPhiBin,phiMin,phiMax,
00201                  nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00202                  nPtBin,ptMin,ptMax);
00203     ew[i].pm[j].h3PhiGlDcaXYGlPtGl->SetXTitle("#phi_{Global}");
00204     ew[i].pm[j].h3PhiGlDcaXYGlPtGl->SetYTitle("sDca_{XY}"); 
00205     ew[i].pm[j].h3PhiGlDcaXYGlPtGl->SetZTitle("Global p_{T} (GeV/c)");
00206 //    ew[i].pm[j].h3PhiGlDcaXYGlPtGl->Sumw2();
00207 
00208     //********** 3d dca, dca xy ,pt
00209     setName(name,"h3DcaGlDcaXYGlPtPr",sEW[i].Data(),sPM[j].Data());
00210     ew[i].pm[j].h3DcaGlDcaXYGlPtPr =
00211       new TH3D(name,name,
00212                nDcaBin,dcaMin,dcaMax,
00213                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00214                nPtBin,ptMin,ptMax);
00215     ew[i].pm[j].h3DcaGlDcaXYGlPtPr->SetXTitle("dca_{3d}");  
00216     ew[i].pm[j].h3DcaGlDcaXYGlPtPr->SetYTitle("sDca_{XY}");
00217     ew[i].pm[j].h3DcaGlDcaXYGlPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00218 //    ew[i].pm[j].h3DcaGlDcaXYGlPtPr->Sumw2();
00219 
00220     setName(name,"h3DcaGlDcaXYGlPtGl",sEW[i].Data(),sPM[j].Data());
00221     ew[i].pm[j].h3DcaGlDcaXYGlPtGl =
00222       new TH3D(name,name,
00223                nDcaBin,dcaMin,dcaMax,
00224                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00225                nPtBin,ptMin,ptMax);
00226     ew[i].pm[j].h3DcaGlDcaXYGlPtGl->SetXTitle("sDca_{3d}");  
00227     ew[i].pm[j].h3DcaGlDcaXYGlPtGl->SetYTitle("Dca_{XY}");
00228     ew[i].pm[j].h3DcaGlDcaXYGlPtGl->SetZTitle("Global p_{T} (GeV/c)");
00229 //    ew[i].pm[j].h3DcaGlDcaXYGlPtGl->Sumw2();
00230 
00231     // for backgrounds
00232     setName(name,"h2SDcaGlPtPrRebin",sEW[i].Data(),sPM[j].Data());
00233     ew[i].pm[j].h2SDcaGlPtPrRebin =
00234       new TH2D(name,name,
00235                nSDcaBin,sDcaMin,sDcaMax,
00236                nPtRebinBin,ptRebinMin,ptRebinMax);
00237     ew[i].pm[j].h2SDcaGlPtPrRebin->SetXTitle("Dca_{3d}");   
00238     ew[i].pm[j].h2SDcaGlPtPrRebin->SetYTitle("Primary p_{T} (GeV/c)");   
00239 //    ew[i].pm[j].h2SDcaGlPtPrRebin->Sumw2();
00240 
00241     setName(name,"h2DcaXYGlPtPrRebin",sEW[i].Data(),sPM[j].Data());
00242     ew[i].pm[j].h2DcaXYGlPtPrRebin =
00243       new TH2D(name,name,
00244                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax,
00245                nPtRebinBin,ptRebinMin,ptRebinMax);
00246     ew[i].pm[j].h2DcaXYGlPtPrRebin->SetXTitle("Dca_{3d}");
00247     ew[i].pm[j].h2DcaXYGlPtPrRebin->SetYTitle("Primary p_{T} (GeV/c)");  
00248 //    ew[i].pm[j].h2DcaXYGlPtPrRebin->Sumw2();
00249 
00250     setName(name,"h2DcaGlPtPrRebin",sEW[i].Data(),sPM[j].Data());
00251     ew[i].pm[j].h2DcaGlPtPrRebin
00252       = new TH2D(name,name,
00253                  nDcaBin,dcaMin,dcaMax,
00254                  nPtRebinBin,ptRebinMin,ptRebinMax);
00255     ew[i].pm[j].h2DcaGlPtPrRebin->SetXTitle("Dca_{3d}");
00256     ew[i].pm[j].h2DcaGlPtPrRebin->SetYTitle("Primary p_{T} (GeV/c)");
00257 //    ew[i].pm[j].h2DcaGlPtPrRebin->Sumw2();    
00258 
00259     //********** PhiPr , fit pts, pt
00260     setName(name,"h3PhiPrFitPtsPtPr",sEW[i].Data(),sPM[j].Data());
00261     ew[i].pm[j].h3PhiPrFitPtsPtPr =
00262       new TH3D(name,name,  
00263                nPhiBin,phiMin,phiMax,
00264                nFitPtsBin,fitPtsMin,fitPtsMax,
00265                nPtBin,ptMin,ptMax);
00266     ew[i].pm[j].h3PhiPrFitPtsPtPr->SetXTitle("#phi_{Primary}");
00267     ew[i].pm[j].h3PhiPrFitPtsPtPr->SetYTitle("Fit Points");
00268     ew[i].pm[j].h3PhiPrFitPtsPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00269 //    ew[i].pm[j].h3PhiPrFitPtsPtPr->Sumw2();
00270 
00271     //********** sector , all pts, pt
00272     setName(name,"h3PhiPrAllPtsPtPr",sEW[i].Data(),sPM[j].Data());
00273     ew[i].pm[j].h3PhiPrAllPtsPtPr =
00274       new TH3D(name,name,
00275                nPhiBin,phiMin,phiMax,
00276                nFitPtsBin,fitPtsMin,fitPtsMax,
00277                nPtBin,ptMin,ptMax);
00278     ew[i].pm[j].h3PhiPrAllPtsPtPr->SetXTitle("#phi_{Primary}"); 
00279     ew[i].pm[j].h3PhiPrAllPtsPtPr->SetYTitle("All Points");
00280     ew[i].pm[j].h3PhiPrAllPtsPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00281 //    ew[i].pm[j].h3PhiPrAllPtsPtPr->Sumw2();
00282 
00283     //********** sector , max pts, pt
00284     setName(name,"h3PhiPrMaxPtsPtPr",sEW[i].Data(),sPM[j].Data());
00285     ew[i].pm[j].h3PhiPrMaxPtsPtPr =
00286       new TH3D(name,name,
00287                nPhiBin,phiMin,phiMax,
00288                nFitPtsBin,fitPtsMin,fitPtsMax,
00289                nPtBin,ptMin,ptMax);
00290     ew[i].pm[j].h3PhiPrMaxPtsPtPr->SetXTitle("#phi_{Primary}"); 
00291     ew[i].pm[j].h3PhiPrMaxPtsPtPr->SetYTitle("Max Points");
00292     ew[i].pm[j].h3PhiPrMaxPtsPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00293 //    ew[i].pm[j].h3PhiPrMaxPtsPtPr->Sumw2();
00294 
00295     //********** vtx z, fit pts, pt
00296     setName(name,"h3VtxZFitPtsPtPr",sEW[i].Data(),sPM[j].Data());
00297     ew[i].pm[j].h3VtxZFitPtsPtPr =
00298       new TH3D(name,name,
00299                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00300                nFitPtsBin,fitPtsMin,fitPtsMax,
00301                nPtBin,ptMin,ptMax);
00302     ew[i].pm[j].h3VtxZFitPtsPtPr->SetXTitle("Z_{vtx} (cm)");
00303     ew[i].pm[j].h3VtxZFitPtsPtPr->SetYTitle("Fit Points");
00304     ew[i].pm[j].h3VtxZFitPtsPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00305 //    ew[i].pm[j].h3VtxZFitPtsPtPr->Sumw2();
00306 
00307     //********* vtx z, fit pts, eta
00308     setName(name,"h3VtxZFitPtsEtaPr",sEW[i].Data(),sPM[j].Data());
00309     ew[i].pm[j].h3VtxZFitPtsEtaPr =
00310       new TH3D(name,name,
00311                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00312                nFitPtsBin,fitPtsMin,fitPtsMax,
00313                nEtaBin,etaMin,etaMax);
00314     ew[i].pm[j].h3VtxZFitPtsEtaPr->SetXTitle("Zvtx (cm)"); 
00315     ew[i].pm[j].h3VtxZFitPtsEtaPr->SetYTitle("Fit Points");
00316     ew[i].pm[j].h3VtxZFitPtsEtaPr->SetZTitle("#eta_{Primary}");
00317 //    ew[i].pm[j].h3VtxZFitPtsEtaPr->Sumw2();
00318     
00319     //********** flow cent, fit pts, pt pr
00320     setName(name,"h3FlowCentFitPtsPtPr",sEW[i].Data(),sPM[j].Data());
00321      ew[i].pm[j].h3FlowCentFitPtsPtPr =
00322       new TH3D(name,name,
00323                nFlowCentBin,flowCentMin,flowCentMax,
00324                nFitPtsCentBin,fitPtsCentMin,fitPtsCentMax,
00325                nPtBin,ptMin,ptMax);
00326     ew[i].pm[j].h3FlowCentFitPtsPtPr->SetXTitle("Flow Centrality");
00327     ew[i].pm[j].h3FlowCentFitPtsPtPr->SetYTitle("Fit Points");
00328     ew[i].pm[j].h3FlowCentFitPtsPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00329 //    ew[i].pm[j].h3FlowCentFitPtsPtPr->Sumw2();    
00330     
00331     //********** vtx, eta, pt
00332     setName(name,"h3VtxZEtaPrPtPr",sEW[i].Data(),sPM[j].Data());
00333     ew[i].pm[j].h3VtxZEtaPrPtPr
00334       = new TH3D(name,name,
00335                  nVertexZBin,vertexZMin,vertexZMax,
00336                  nEtaSmallBin,etaSmallMin,etaSmallMax,
00337                  nPtBin,ptMin,ptMax);
00338     ew[i].pm[j].h3VtxZEtaPrPtPr->SetXTitle("Zvtx (cm)");  
00339     ew[i].pm[j].h3VtxZEtaPrPtPr->SetYTitle("#eta_{Primary}");
00340     ew[i].pm[j].h3VtxZEtaPrPtPr->SetZTitle("Primary p_{T} (GeV/c)");
00341 //    ew[i].pm[j].h3VtxZEtaPrPtPr->Sumw2();
00342 
00343     setName(name,"h3VtxZEtaGlPtGl",sEW[i].Data(),sPM[j].Data());
00344     ew[i].pm[j].h3VtxZEtaGlPtGl
00345       = new TH3D(name,name,
00346                  nVertexZBin,vertexZMin,vertexZMax,
00347                  nEtaSmallBin,etaSmallMin,etaSmallMax,
00348                  nPtBin,ptMin,ptMax);
00349     ew[i].pm[j].h3VtxZEtaGlPtGl->SetXTitle("Zvtx (cm)");  
00350     ew[i].pm[j].h3VtxZEtaGlPtGl->SetYTitle("#eta_{Global}");
00351     ew[i].pm[j].h3VtxZEtaGlPtGl->SetZTitle("Global p_{T} (GeV/c)");
00352 //    ew[i].pm[j].h3VtxZEtaGlPtGl->Sumw2();
00353 
00354     // varying bins RAW spectra     
00355     setName(name,"RawPtGlVarBin0",sEW[i].Data(),sPM[j].Data());
00356     ew[i].pm[j].h1RawPtGlVarBin0
00357       = new TH1D(name,name,bins0->GetSize()-1,bins0->GetArray());
00358     ew[i].pm[j].h1RawPtGlVarBin0->SetXTitle("Global p_{T} (GeV/c)");
00359     ew[i].pm[j].h1RawPtGlVarBin0->Sumw2();
00360 
00361     setName(name,"RawPtGlVarBin1",sEW[i].Data(),sPM[j].Data());
00362     ew[i].pm[j].h1RawPtGlVarBin1
00363       = new TH1D(name,name,bins1->GetSize()-1,bins1->GetArray());
00364     ew[i].pm[j].h1RawPtGlVarBin1->SetXTitle("Global p_{T} (GeV/c)");
00365     ew[i].pm[j].h1RawPtGlVarBin1->Sumw2();
00366 
00367     setName(name,"RawPtPrVarBin0",sEW[i].Data(),sPM[j].Data());
00368     ew[i].pm[j].h1RawPtPrVarBin0
00369       = new TH1D(name,name,bins0->GetSize()-1,bins0->GetArray());
00370     ew[i].pm[j].h1RawPtPrVarBin0->SetXTitle("Primary p_{T} (GeV/c)");
00371     ew[i].pm[j].h1RawPtPrVarBin0->Sumw2();
00372 
00373     setName(name,"RawPtPrVarBin1",sEW[i].Data(),sPM[j].Data());
00374     ew[i].pm[j].h1RawPtPrVarBin1
00375       = new TH1D(name,name,bins1->GetSize()-1,bins1->GetArray());
00376     ew[i].pm[j].h1RawPtPrVarBin1->SetXTitle("Primary p_{T} (GeV/c)");
00377     ew[i].pm[j].h1RawPtPrVarBin1->Sumw2();
00378 
00379     // varying bins ONEOVERPT spectra     
00380     setName(name,"OneOverPtGlVarBin0",sEW[i].Data(),sPM[j].Data());
00381     ew[i].pm[j].h1OneOverPtGlVarBin0
00382       = new TH1D(name,name,bins0->GetSize()-1,bins0->GetArray());
00383     ew[i].pm[j].h1OneOverPtGlVarBin0->SetXTitle("Global p_{T} (GeV/c)");
00384     ew[i].pm[j].h1OneOverPtGlVarBin0->Sumw2();
00385 
00386     setName(name,"OneOverPtGlVarBin1",sEW[i].Data(),sPM[j].Data());
00387     ew[i].pm[j].h1OneOverPtGlVarBin1
00388       = new TH1D(name,name,bins1->GetSize()-1,bins1->GetArray());
00389     ew[i].pm[j].h1OneOverPtGlVarBin1->SetXTitle("Global p_{T} (GeV/c)");
00390     ew[i].pm[j].h1OneOverPtGlVarBin1->Sumw2();
00391 
00392     setName(name,"OneOverPtPrVarBin0",sEW[i].Data(),sPM[j].Data());
00393     ew[i].pm[j].h1OneOverPtPrVarBin0
00394       = new TH1D(name,name,bins0->GetSize()-1,bins0->GetArray());
00395     ew[i].pm[j].h1OneOverPtPrVarBin0->SetXTitle("Primary p_{T} (GeV/c)");
00396     ew[i].pm[j].h1OneOverPtPrVarBin0->Sumw2();
00397 
00398     setName(name,"OneOverPtPrVarBin1",sEW[i].Data(),sPM[j].Data());
00399     ew[i].pm[j].h1OneOverPtPrVarBin1
00400       = new TH1D(name,name,bins1->GetSize()-1,bins1->GetArray());
00401     ew[i].pm[j].h1OneOverPtPrVarBin1->SetXTitle("Primary p_{T} (GeV/c)");
00402     ew[i].pm[j].h1OneOverPtPrVarBin1->Sumw2();
00403 
00404     // varying bins WEIGHTEDMEAN spectra     
00405     setName(name,"WeightedMeanPtGlVarBin0",sEW[i].Data(),sPM[j].Data());
00406     ew[i].pm[j].h1WeightedMeanPtGlVarBin0
00407       = new TH1D(name,name,bins0->GetSize()-1,bins0->GetArray());
00408     ew[i].pm[j].h1WeightedMeanPtGlVarBin0->SetXTitle("Global p_{T} (GeV/c)");
00409     ew[i].pm[j].h1WeightedMeanPtGlVarBin0->Sumw2();
00410 
00411     setName(name,"WeightedMeanPtGlVarBin1",sEW[i].Data(),sPM[j].Data());
00412     ew[i].pm[j].h1WeightedMeanPtGlVarBin1
00413       = new TH1D(name,name,bins1->GetSize()-1,bins1->GetArray());
00414     ew[i].pm[j].h1WeightedMeanPtGlVarBin1->SetXTitle("Global p_{T} (GeV/c)");
00415     ew[i].pm[j].h1WeightedMeanPtGlVarBin1->Sumw2();
00416 
00417     setName(name,"WeightedMeanPtPrVarBin0",sEW[i].Data(),sPM[j].Data());
00418     ew[i].pm[j].h1WeightedMeanPtPrVarBin0
00419       = new TH1D(name,name,bins0->GetSize()-1,bins0->GetArray());
00420     ew[i].pm[j].h1WeightedMeanPtPrVarBin0->SetXTitle("Primary p_{T} (GeV/c)");
00421     ew[i].pm[j].h1WeightedMeanPtPrVarBin0->Sumw2();
00422 
00423     setName(name,"WeightedMeanPtPrVarBin1",sEW[i].Data(),sPM[j].Data());
00424     ew[i].pm[j].h1WeightedMeanPtPrVarBin1
00425       = new TH1D(name,name,bins1->GetSize()-1,bins1->GetArray());
00426     ew[i].pm[j].h1WeightedMeanPtPrVarBin1->SetXTitle("Primary p_{T} (GeV/c)");
00427     ew[i].pm[j].h1WeightedMeanPtPrVarBin1->Sumw2();
00428                  
00429     } //PM    
00430   } //EW
00431 
00432 
00433 
00434 }
00435 //______________________
00436 
00437 
00438 void 
00439 StHiAnalysis::trackLoop()
00440 {
00441   //Standard event cut on vertexZ, centrality and triggerword are already done
00442 
00443   if(mDebug)
00444     cout << "StHiAnalysis::trackLoop()" << endl;
00445 
00446   //Need this for EAST/WEST analysis
00447   Float_t vertexZ = mHiMicroEvent->VertexZ();
00448 
00449   Float_t flowCent   = flowCentrality(mHiMicroEvent->NUncorrectedPrimaries());
00450 
00451   Int_t nTrack = mHiMicroEvent->NTrack();
00452   StHiMicroTrack* track;
00453 
00454   for(Int_t i=0; i<nTrack; i++){
00455     track =(StHiMicroTrack*) mHiMicroEvent->tracks()->At(i);
00456 
00457     Int_t iCharge = (track->Charge()>0) ? 0 : 1; //plus is 0
00458 
00459     Float_t ptPr  = track->PtPr();
00460     Float_t ptGl  = track->PtGl();
00461     Float_t resPtPrGlPr = (ptPr-ptGl)/ptPr;
00462     Float_t resPtPrGlGl = (ptPr-ptGl)/ptGl;
00463 
00464     Float_t etaGl = track->EtaGl();
00465     Float_t etaPr  = track->EtaPr();
00466 
00467     Float_t phiPr = track->PhiPr();
00468     Float_t phiGl = track->PhiGl();
00469  //   Float_t phiGlDeg = phiGl*180./TMath::Pi();
00470  //   Float_t phiPrDeg = phiPr*180./TMath::Pi();
00471 
00472     Float_t sector = track->FirstSector();    
00473 
00474     Float_t sDcaGl = (track->DcaXYGl()>0) ? track->DcaGl() : -track->DcaGl();
00475     Float_t dcaXYGl = track->DcaXYGl();
00476     Float_t dcaGl = track->DcaGl();
00477 
00478     Float_t fitPts = track->FitPts();
00479     Float_t allPts = track->AllPts();
00480     Float_t maxPts = track->MaxPossPts();
00481 
00482     h1FitPts->Fill(fitPts);
00483 
00484     if(CutRc::AcceptEta(track) && CutRc::AcceptFirstPadrow(track) && CutRc::AcceptSameSector(track)) {
00485       
00486       if(CutRc::AcceptSDcaGl(track)) {
00487         h2FitPtsVsSector->Fill(sector,fitPts);
00488         h2MaxPtsVsSector->Fill(sector,maxPts);
00489         h2AllPtsVsSector->Fill(sector,allPts);
00490       }
00491       if(CutRc::AcceptFitPts(track)) {
00492         h2DcaGlVsSector->Fill(sector,dcaGl);
00493         h2DcaXYGlVsSector->Fill(sector,dcaXYGl);
00494       }
00495     }
00496 
00497     //Standard track cuts are |eta|<0.75,fitpts>20,SDca<1cm
00498     if(CutRc::Accept(track)) {
00499       h1YieldVsSector->Fill(sector);  
00500       h2PrPtVsSector->Fill(sector,ptPr);
00501       h2GlPtVsSector->Fill(sector,ptGl);
00502       h2ResPrPtVsSector->Fill(sector,resPtPrGlPr);
00503       h2ResGlPtVsSector->Fill(sector,resPtPrGlGl);
00504     }
00505 
00506 //Bum's stuff
00507 
00508     //*********** AcceptNoeta = dca, fitpts and samesector
00509     
00510     if(CutRc::AcceptNoEta(track)){
00511       if(CutRc::AcceptEastSideTrack(track)) {
00512         ew[0].pm[iCharge].h3VtxZEtaPrPtPr->Fill(vertexZ,etaPr,ptPr);
00513         ew[0].pm[iCharge].h3VtxZEtaGlPtGl->Fill(vertexZ,etaGl,ptGl);
00514         ew[0].pm[2].h3VtxZEtaPrPtPr->Fill(vertexZ,etaPr,ptPr);
00515         ew[0].pm[2].h3VtxZEtaGlPtGl->Fill(vertexZ,etaGl,ptGl);
00516       }
00517       if(CutRc::AcceptWestSideTrack(track)) {
00518         ew[1].pm[iCharge].h3VtxZEtaPrPtPr->Fill(vertexZ,etaPr,ptPr);
00519         ew[1].pm[iCharge].h3VtxZEtaGlPtGl->Fill(vertexZ,etaGl,ptGl);
00520         ew[1].pm[2].h3VtxZEtaPrPtPr->Fill(vertexZ,etaPr,ptPr);
00521         ew[1].pm[2].h3VtxZEtaGlPtGl->Fill(vertexZ,etaGl,ptGl);
00522       }
00523       ew[2].pm[2].h3VtxZEtaPrPtPr->Fill(vertexZ,etaPr,ptPr);
00524       ew[2].pm[2].h3VtxZEtaGlPtGl->Fill(vertexZ,etaGl,ptGl);
00525       ew[2].pm[iCharge].h3VtxZEtaPrPtPr->Fill(vertexZ,etaPr,ptPr);
00526       ew[2].pm[iCharge].h3VtxZEtaGlPtGl->Fill(vertexZ,etaGl,ptGl);
00527     }
00528 
00529     //****** Eta cut
00530 
00531     if(CutRc::AcceptEta(track)){
00532       if(CutRc::AcceptFitPts(track)){
00533 
00534         if(CutRc::AcceptEastSideTrack(track)) {
00535          // sector,dcaxy,pt
00536          ew[0].pm[iCharge].h3PhiPrDcaXYGlPtPr->Fill(phiPr,dcaXYGl,ptPr);
00537          ew[0].pm[iCharge].h3PhiGlDcaXYGlPtGl->Fill(phiGl,dcaXYGl,ptGl);
00538          ew[0].pm[2].h3PhiPrDcaXYGlPtPr->Fill(phiPr,dcaXYGl,ptPr);
00539          ew[0].pm[2].h3PhiGlDcaXYGlPtGl->Fill(phiGl,dcaXYGl,ptGl);
00540          // dca3d, dcaxy,pt
00541          ew[0].pm[iCharge].h3DcaGlDcaXYGlPtPr->Fill(dcaGl,dcaXYGl,ptPr);
00542          ew[0].pm[iCharge].h3DcaGlDcaXYGlPtGl->Fill(dcaGl,dcaXYGl,ptGl);
00543          ew[0].pm[2].h3DcaGlDcaXYGlPtPr->Fill(dcaGl,dcaXYGl,ptPr);
00544          ew[0].pm[2].h3DcaGlDcaXYGlPtGl->Fill(dcaGl,dcaXYGl,ptGl);
00545          // rebin?
00546          ew[0].pm[iCharge].h2SDcaGlPtPrRebin->Fill(sDcaGl,ptPr);
00547          ew[0].pm[2].h2SDcaGlPtPrRebin->Fill(sDcaGl,ptPr);
00548          // dcaxy,pt
00549          ew[0].pm[iCharge].h2DcaXYGlPtPrRebin->Fill(dcaXYGl,ptPr);
00550          ew[0].pm[2].h2DcaXYGlPtPrRebin->Fill(dcaXYGl,ptPr);
00551         }
00552         if(CutRc::AcceptWestSideTrack(track)) {
00553          // sector,dcaxy,pt
00554          ew[1].pm[iCharge].h3PhiPrDcaXYGlPtPr->Fill(phiPr,dcaXYGl,ptPr);
00555          ew[1].pm[iCharge].h3PhiGlDcaXYGlPtGl->Fill(phiGl,dcaXYGl,ptGl);
00556          ew[1].pm[2].h3PhiPrDcaXYGlPtPr->Fill(phiPr,dcaXYGl,ptPr);
00557          ew[1].pm[2].h3PhiGlDcaXYGlPtGl->Fill(phiGl,dcaXYGl,ptGl);
00558          // dca3d, dcaxy,pt
00559          ew[1].pm[iCharge].h3DcaGlDcaXYGlPtPr->Fill(dcaGl,dcaXYGl,ptPr);
00560          ew[1].pm[iCharge].h3DcaGlDcaXYGlPtGl->Fill(dcaGl,dcaXYGl,ptGl);
00561          ew[1].pm[2].h3DcaGlDcaXYGlPtPr->Fill(dcaGl,dcaXYGl,ptPr);
00562          ew[1].pm[2].h3DcaGlDcaXYGlPtGl->Fill(dcaGl,dcaXYGl,ptGl);
00563          // rebin?
00564          ew[1].pm[iCharge].h2SDcaGlPtPrRebin->Fill(sDcaGl,ptPr);
00565          ew[1].pm[2].h2SDcaGlPtPrRebin->Fill(sDcaGl,ptPr);
00566          // dcaxy,pt
00567          ew[1].pm[iCharge].h2DcaXYGlPtPrRebin->Fill(dcaXYGl,ptPr);
00568          ew[1].pm[2].h2DcaXYGlPtPrRebin->Fill(dcaXYGl,ptPr);
00569         }
00570         // sector,dcaxy,pt
00571         ew[2].pm[2].h3PhiPrDcaXYGlPtPr->Fill(phiPr,dcaXYGl,ptPr);
00572         ew[2].pm[2].h3PhiGlDcaXYGlPtGl->Fill(phiGl,dcaXYGl,ptGl);
00573         ew[2].pm[iCharge].h3PhiPrDcaXYGlPtPr->Fill(phiPr,dcaXYGl,ptPr);
00574         ew[2].pm[iCharge].h3PhiGlDcaXYGlPtGl->Fill(phiGl,dcaXYGl,ptGl);
00575         // dca3d, dcaxy,pt
00576         ew[2].pm[2].h3DcaGlDcaXYGlPtPr->Fill(dcaGl,dcaXYGl,ptPr);
00577         ew[2].pm[2].h3DcaGlDcaXYGlPtGl->Fill(dcaGl,dcaXYGl,ptGl);
00578         ew[2].pm[iCharge].h3DcaGlDcaXYGlPtPr->Fill(dcaGl,dcaXYGl,ptPr);
00579         ew[2].pm[iCharge].h3DcaGlDcaXYGlPtGl->Fill(dcaGl,dcaXYGl,ptGl);
00580         // rebin?
00581         ew[2].pm[2].h2SDcaGlPtPrRebin->Fill(sDcaGl,ptPr);
00582         ew[2].pm[iCharge].h2SDcaGlPtPrRebin->Fill(sDcaGl,ptPr);
00583         // dcaxy,pt
00584         ew[2].pm[2].h2DcaXYGlPtPrRebin->Fill(dcaXYGl,ptPr);
00585         ew[2].pm[iCharge].h2DcaXYGlPtPrRebin->Fill(dcaXYGl,ptPr);
00586 
00587         // respt, pt,dcaxy
00588         // no charge difference
00589         h3ResPtPrGlPtPrDcaXYGl->Fill(resPtPrGlPr,ptPr,dcaXYGl);
00590         h3ResPtPrGlPtGlDcaXYGl->Fill(resPtPrGlGl,ptGl,dcaXYGl);
00591       
00592       }//AcceptFitPts(track)
00593 
00594       //*********eta and dca cut
00595       if(CutRc::AcceptSDcaGl(track)){
00596         if(CutRc::AcceptEastSideTrack(track)) {
00597           // sector,fit pts, pt
00598           ew[0].pm[iCharge].h3PhiPrFitPtsPtPr->Fill(phiPr,fitPts,ptPr);
00599           ew[0].pm[2].h3PhiPrFitPtsPtPr->Fill(phiPr,fitPts,ptPr);
00600           // sector, all pts, pt
00601           ew[0].pm[iCharge].h3PhiPrAllPtsPtPr->Fill(phiPr,allPts,ptPr);
00602           ew[0].pm[2].h3PhiPrAllPtsPtPr->Fill(phiPr,allPts,ptPr);
00603           // sector, max pts, pt
00604           ew[0].pm[iCharge].h3PhiPrMaxPtsPtPr->Fill(phiPr,maxPts,ptPr);
00605           ew[0].pm[2].h3PhiPrMaxPtsPtPr->Fill(phiPr,maxPts,ptPr);
00606           // flow, fit pts, pt
00607           ew[0].pm[iCharge].h3FlowCentFitPtsPtPr->Fill(flowCent,fitPts,ptPr);
00608           ew[0].pm[2].h3FlowCentFitPtsPtPr->Fill(flowCent,fitPts,ptPr);
00609         }
00610         if(CutRc::AcceptWestSideTrack(track)) {
00611           // sector,fit pts, pt
00612           ew[1].pm[iCharge].h3PhiPrFitPtsPtPr->Fill(phiPr,fitPts,ptPr);
00613           ew[1].pm[2].h3PhiPrFitPtsPtPr->Fill(phiPr,fitPts,ptPr);
00614           // sector, all pts, pt
00615           ew[1].pm[iCharge].h3PhiPrAllPtsPtPr->Fill(phiPr,allPts,ptPr);
00616           ew[1].pm[2].h3PhiPrAllPtsPtPr->Fill(phiPr,allPts,ptPr);
00617           // sector, max pts, pt
00618           ew[1].pm[iCharge].h3PhiPrMaxPtsPtPr->Fill(phiPr,maxPts,ptPr);
00619           ew[1].pm[2].h3PhiPrMaxPtsPtPr->Fill(phiPr,maxPts,ptPr);
00620           // flow, fit pts, pt
00621           ew[1].pm[iCharge].h3FlowCentFitPtsPtPr->Fill(flowCent,fitPts,ptPr);
00622           ew[1].pm[2].h3FlowCentFitPtsPtPr->Fill(flowCent,fitPts,ptPr);
00623         }
00624         // sector,fit pts, pt
00625         ew[2].pm[2].h3PhiPrFitPtsPtPr->Fill(phiPr,fitPts,ptPr);
00626         ew[2].pm[iCharge].h3PhiPrFitPtsPtPr->Fill(phiPr,fitPts,ptPr);
00627         // sector, all pts, pt
00628         ew[2].pm[2].h3PhiPrAllPtsPtPr->Fill(phiPr,allPts,ptPr);
00629         ew[2].pm[iCharge].h3PhiPrAllPtsPtPr->Fill(phiPr,allPts,ptPr);
00630         // sector, max pts, pt
00631         ew[2].pm[2].h3PhiPrMaxPtsPtPr->Fill(phiPr,maxPts,ptPr);
00632         ew[2].pm[iCharge].h3PhiPrMaxPtsPtPr->Fill(phiPr,maxPts,ptPr);
00633         // flow, fit pts, pt
00634         ew[2].pm[2].h3FlowCentFitPtsPtPr->Fill(flowCent,fitPts,ptPr);
00635         ew[2].pm[iCharge].h3FlowCentFitPtsPtPr->Fill(flowCent,fitPts,ptPr);
00636 
00637       } //dca
00638     }//eta
00639 
00640     //******** dca and tight eta cut
00641     if(CutRc::AcceptSDcaGl(track) && fabs(etaPr)<.1){
00642       // vtx z, fit pts, pt
00643       if(CutRc::AcceptEastSideTrack(track)) {
00644         ew[0].pm[iCharge].h3VtxZFitPtsPtPr->Fill(vertexZ,fitPts,ptPr);
00645         ew[0].pm[2].h3VtxZFitPtsPtPr->Fill(vertexZ,fitPts,ptPr);
00646       }
00647       if(CutRc::AcceptWestSideTrack(track)) {
00648         ew[1].pm[iCharge].h3VtxZFitPtsPtPr->Fill(vertexZ,fitPts,ptPr);
00649         ew[1].pm[2].h3VtxZFitPtsPtPr->Fill(vertexZ,fitPts,ptPr);
00650       }
00651       ew[2].pm[2].h3VtxZFitPtsPtPr->Fill(vertexZ,fitPts,ptPr);
00652       ew[2].pm[iCharge].h3VtxZFitPtsPtPr->Fill(vertexZ,fitPts,ptPr);
00653     } 
00654 
00655     // dca and pt
00656     if(CutRc::AcceptSDcaGl(track) && ptPr>4 && ptPr<6){
00657       // vtx z, fit pts, eta
00658       if(CutRc::AcceptEastSideTrack(track)) {
00659         ew[0].pm[iCharge].h3VtxZFitPtsEtaPr->Fill(vertexZ,fitPts,etaPr);
00660         ew[0].pm[2].h3VtxZFitPtsEtaPr->Fill(vertexZ,fitPts,etaPr);
00661       }
00662       if(CutRc::AcceptWestSideTrack(track)) {
00663         ew[1].pm[iCharge].h3VtxZFitPtsEtaPr->Fill(vertexZ,fitPts,etaPr);
00664         ew[1].pm[2].h3VtxZFitPtsEtaPr->Fill(vertexZ,fitPts,etaPr);
00665       }
00666       ew[2].pm[2].h3VtxZFitPtsEtaPr->Fill(vertexZ,fitPts,etaPr);
00667       ew[2].pm[iCharge].h3VtxZFitPtsEtaPr->Fill(vertexZ,fitPts,etaPr);
00668     }
00669 
00670     // all cuts
00671     if(CutRc::Accept(track)){
00672       // count and centrality and spectra
00673       if(CutRc::AcceptEastSideTrack(track)) {
00674        ew[0].pm[iCharge].h2CentralityPtPr->Fill(flowCent,ptPr);
00675        ew[0].pm[2].h2CentralityPtPr->Fill(flowCent,ptPr);
00676 
00677         //Global RAW
00678         ew[0].pm[iCharge].h1RawPtGlVarBin0->Fill(ptGl);
00679         ew[0].pm[iCharge].h1RawPtGlVarBin1->Fill(ptGl);
00680         ew[0].pm[2].h1RawPtGlVarBin0->Fill(ptGl);
00681         ew[0].pm[2].h1RawPtGlVarBin1->Fill(ptGl);
00682         //Global ONEOVERPT
00683         ew[0].pm[iCharge].h1OneOverPtGlVarBin0->Fill(ptGl,1./ptGl);
00684         ew[0].pm[iCharge].h1OneOverPtGlVarBin1->Fill(ptGl,1./ptGl);
00685         ew[0].pm[2].h1OneOverPtGlVarBin0->Fill(ptGl,1./ptGl);
00686         ew[0].pm[2].h1OneOverPtGlVarBin1->Fill(ptGl,1./ptGl);
00687         //Primary RAW 
00688         ew[0].pm[iCharge].h1RawPtPrVarBin0->Fill(ptPr);
00689         ew[0].pm[iCharge].h1RawPtPrVarBin1->Fill(ptPr);
00690         ew[0].pm[2].h1RawPtPrVarBin0->Fill(ptPr);
00691         ew[0].pm[2].h1RawPtPrVarBin1->Fill(ptPr);
00692         //Primary ONEOVERPT
00693         ew[0].pm[iCharge].h1OneOverPtPrVarBin0->Fill(ptPr,1./ptPr);
00694         ew[0].pm[iCharge].h1OneOverPtPrVarBin1->Fill(ptPr,1./ptPr);
00695         ew[0].pm[2].h1OneOverPtPrVarBin0->Fill(ptPr,1./ptPr);
00696         ew[0].pm[2].h1OneOverPtPrVarBin1->Fill(ptPr,1./ptPr);
00697       }
00698       if(CutRc::AcceptWestSideTrack(track)) {
00699        ew[1].pm[iCharge].h2CentralityPtPr->Fill(flowCent,ptPr);
00700        ew[1].pm[2].h2CentralityPtPr->Fill(flowCent,ptPr);
00701 
00702         //Global RAW
00703         ew[1].pm[iCharge].h1RawPtGlVarBin0->Fill(ptGl);
00704         ew[1].pm[iCharge].h1RawPtGlVarBin1->Fill(ptGl);
00705         ew[1].pm[2].h1RawPtGlVarBin0->Fill(ptGl);
00706         ew[1].pm[2].h1RawPtGlVarBin1->Fill(ptGl);
00707         //Global ONEOVERPT
00708         ew[1].pm[iCharge].h1OneOverPtGlVarBin0->Fill(ptGl,1./ptGl);
00709         ew[1].pm[iCharge].h1OneOverPtGlVarBin1->Fill(ptGl,1./ptGl);
00710         ew[1].pm[2].h1OneOverPtGlVarBin0->Fill(ptGl,1./ptGl);
00711         ew[1].pm[2].h1OneOverPtGlVarBin1->Fill(ptGl,1./ptGl);
00712         //Primary RAW
00713         ew[1].pm[iCharge].h1RawPtPrVarBin0->Fill(ptPr);
00714         ew[1].pm[iCharge].h1RawPtPrVarBin1->Fill(ptPr);
00715         ew[1].pm[2].h1RawPtPrVarBin0->Fill(ptPr);
00716         ew[1].pm[2].h1RawPtPrVarBin1->Fill(ptPr);
00717         //Primary ONEOVERPT
00718         ew[1].pm[iCharge].h1OneOverPtPrVarBin0->Fill(ptPr,1./ptPr);
00719         ew[1].pm[iCharge].h1OneOverPtPrVarBin1->Fill(ptPr,1./ptPr);
00720         ew[1].pm[2].h1OneOverPtPrVarBin0->Fill(ptPr,1./ptPr);
00721         ew[1].pm[2].h1OneOverPtPrVarBin1->Fill(ptPr,1./ptPr);
00722       }
00723       ew[2].pm[2].h2CentralityPtPr->Fill(flowCent,ptPr);
00724       ew[2].pm[iCharge].h2CentralityPtPr->Fill(flowCent,ptPr);
00725 
00726       //Global RAW
00727       ew[2].pm[2].h1RawPtGlVarBin0->Fill(ptGl);
00728       ew[2].pm[2].h1RawPtGlVarBin1->Fill(ptGl);
00729       ew[2].pm[iCharge].h1RawPtGlVarBin0->Fill(ptGl);
00730       ew[2].pm[iCharge].h1RawPtGlVarBin1->Fill(ptGl);
00731       //Global ONEOVERPT
00732       ew[2].pm[2].h1OneOverPtGlVarBin0->Fill(ptGl,1./ptGl);
00733       ew[2].pm[2].h1OneOverPtGlVarBin1->Fill(ptGl,1./ptGl);
00734       ew[2].pm[iCharge].h1OneOverPtGlVarBin0->Fill(ptGl,1./ptGl);
00735       ew[2].pm[iCharge].h1OneOverPtGlVarBin1->Fill(ptGl,1./ptGl);
00736       //Primary RAW
00737       ew[2].pm[2].h1RawPtPrVarBin0->Fill(ptPr);
00738       ew[2].pm[2].h1RawPtPrVarBin1->Fill(ptPr);
00739       ew[2].pm[iCharge].h1RawPtPrVarBin0->Fill(ptPr);
00740       ew[2].pm[iCharge].h1RawPtPrVarBin1->Fill(ptPr);
00741       //Primary ONEOVERPT
00742       ew[2].pm[2].h1OneOverPtPrVarBin0->Fill(ptPr,1./ptPr);
00743       ew[2].pm[2].h1OneOverPtPrVarBin1->Fill(ptPr,1./ptPr);
00744       ew[2].pm[iCharge].h1OneOverPtPrVarBin0->Fill(ptPr,1./ptPr);
00745       ew[2].pm[iCharge].h1OneOverPtPrVarBin1->Fill(ptPr,1./ptPr);
00746     }
00747 
00748   } // tracks
00749          
00750   if(mDebug)
00751     cout << "\ttracks : " << nTrack << endl;
00752 
00753 }
00754 //_____________________
00755 
00756 void
00757 StHiAnalysis::fillEventHistograms()
00758 {
00759      Float_t flowCent   = flowCentrality(mHiMicroEvent->NUncorrectedPrimaries());
00760      Float_t Nch = mHiMicroEvent->NUncorrectedPrimaries();
00761      Float_t NGoodGlobals = mHiMicroEvent->NGoodGlobals();
00762      Float_t ZDCSum = mHiMicroEvent->ZDCe() + mHiMicroEvent->ZDCw();
00763      Float_t CTB = mHiMicroEvent->CTB();
00764      Float_t zvtx = mHiMicroEvent->VertexZ(); 
00765      Float_t yvtx = mHiMicroEvent->VertexY(); 
00766      Float_t xvtx = mHiMicroEvent->VertexX(); 
00767 
00768    //This comes before we make event cuts
00769    //Except we need to make sure and do trigger word cut!!!!
00770    if (CutRc::AcceptTrgWord(mHiMicroEvent)) {
00771      if(CutRc::AcceptCent(mHiMicroEvent)) { //Want uncut vertex distribution for selected trgword and centrality
00772        h3VertexXYZ->Fill(xvtx,yvtx,zvtx);
00773      }
00774      if(CutRc::AcceptVertexZ(mHiMicroEvent)) { //Want uncut centrality distributions for selected trgword and vertexZ
00775       h1FlowCent->Fill(flowCent);
00776       h2ZDCSumVsCTB->Fill(CTB,ZDCSum);
00777      }
00778 
00779      if (acceptEvent(mHiMicroEvent)) {
00780        h2NGoodGlobalsVsNch->Fill(Nch,NGoodGlobals);
00781      }
00782    } //Check Trigger Word
00783 }
00784 
00785 //______________________
00786 
00787 void
00788 StHiAnalysis::finishHistograms()
00789 {
00790   h1NEvent->SetBinContent(1,mNEventAccepted);
00791   h1EtaCut->SetBinContent(1,CutRc::mEta[0]);
00792   h1EtaCut->SetBinContent(2,CutRc::mEta[1]);
00793 
00794   //Make weighted mean distributions...
00795   for (int iEW = 0; iEW < 3; iEW++) {
00796     for (int iPM = 0; iPM < 3; iPM++) {
00797       ew[iEW].pm[iPM].h1WeightedMeanPtGlVarBin0->Divide(ew[iEW].pm[iPM].h1RawPtGlVarBin0,ew[iEW].pm[iPM].h1OneOverPtGlVarBin0);
00798       ew[iEW].pm[iPM].h1WeightedMeanPtGlVarBin1->Divide(ew[iEW].pm[iPM].h1RawPtGlVarBin1,ew[iEW].pm[iPM].h1OneOverPtGlVarBin1);
00799       ew[iEW].pm[iPM].h1WeightedMeanPtPrVarBin0->Divide(ew[iEW].pm[iPM].h1RawPtPrVarBin0,ew[iEW].pm[iPM].h1OneOverPtPrVarBin0);
00800       ew[iEW].pm[iPM].h1WeightedMeanPtPrVarBin1->Divide(ew[iEW].pm[iPM].h1RawPtPrVarBin1,ew[iEW].pm[iPM].h1OneOverPtPrVarBin1);
00801     }
00802   }
00803 
00804 }
00805 //______________
00806 
00807 
00808 ClassImp(StHiAnalysis)
00809