StRoot: StHighptPool/StHiMicroAnalysis/StDcaAnalysis.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StDcaAnalysis.cxx,v 1.3 2002/05/31 21:58:29 jklay Exp $
00004  *
00005  * Author: Bum Choi, UT Austin, Apr 2002
00006  *
00007  ***************************************************************************
00008  *
00009  * Description:  Class to look at DCA information from highpt uDSTs
00010  *
00011  *
00012  ***************************************************************************
00013  *
00014  * $Log: StDcaAnalysis.cxx,v $
00015  * Revision 1.3  2002/05/31 21:58:29  jklay
00016  * Updated analysis code to use new cut class
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  **************************************************************************/
00026 #include "StDcaAnalysis.h"
00027 
00028 enum TYPE { MEAN=0,RMS,NUM,SKEW};
00029 
00030 //__________________
00031 
00032 StDcaAnalysis::StDcaAnalysis(const char* inputDir,
00033                            const char* outRootName)
00034   :  StHiBaseAnalysis(inputDir,outRootName)
00035      
00036 {
00037 
00038 
00039 }
00040 
00041 //__________________
00042 
00043 StDcaAnalysis::~StDcaAnalysis()
00044 {
00045 }
00046 
00047 
00048 //_____________________________
00049 
00050 void
00051 StDcaAnalysis::initHistograms()
00052 {
00053   cout << "StDcaAnalysis::initHistograms()" << endl;
00054   
00055   char name[100];
00056 
00057   //***********************
00058   
00059   using namespace Bin;
00060 
00061   //***********************
00062 
00063   /*
00064   Double_t sectorMin, sectorMax;
00065 
00066   if(CutRc::Half() == 'w'){
00067     sectorMin = sectorWestMin;
00068     sectorMax = sectorWestMax;
00069   }
00070   else{
00071     sectorMin = sectorEastMin;
00072     sectorMax = sectorEastMax;
00073   }
00074   */
00075   //  int netabin=6; double etamin=-.5,etamax=.5;
00076 
00077   char* type[] = {"Mean","Rms","Num" };
00078 
00079   for(int i=0; i<3; i++){
00080     // global pt
00081     sprintf(name,"h%sPosDcaXYGlPtZFD",type[i]); 
00082     dca[i].hPosGlPtZFD =
00083       new TH3D(name,name,
00084                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00085                nPhiBin,phiDegMin,phiDegMax,
00086                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00087 
00088     sprintf(name,"h%sNegDcaXYGlPtZFD",type[i]); 
00089     dca[i].hNegGlPtZFD =
00090       new TH3D(name,name,
00091                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00092                nPhiBin,phiDegMin,phiDegMax,
00093                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00094 
00095     sprintf(name,"h%sPosPlusNegDcaXYGlPtZFD",type[i]); 
00096     dca[i].hPosPlusNegGlPtZFD =
00097       new TH3D(name,name,
00098                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00099                nPhiBin,phiDegMin,phiDegMax,
00100                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00101 
00102     sprintf(name,"h%sPosMinusNegDcaXYGlPtZFD",type[i]); 
00103     dca[i].hPosMinusNegGlPtZFD =
00104       new TH3D(name,name,
00105                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00106                nPhiBin,phiDegMin,phiDegMax,
00107                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00108     // primary pt
00109     sprintf(name,"h%sPosDcaXYPrPtZFD",type[i]); 
00110     dca[i].hPosPrPtZFD =
00111       new TH3D(name,name,
00112                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00113                nPhiBin,phiDegMin,phiDegMax,
00114                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00115 
00116     sprintf(name,"h%sNegDcaXYPrPtZFD",type[i]); 
00117     dca[i].hNegPrPtZFD =
00118       new TH3D(name,name,
00119                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00120                nPhiBin,phiDegMin,phiDegMax,
00121                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00122 
00123     sprintf(name,"h%sPosPlusNegDcaXYPrPtZFD",type[i]); 
00124     dca[i].hPosPlusNegPrPtZFD =
00125       new TH3D(name,name,
00126                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00127                nPhiBin,phiDegMin,phiDegMax,
00128                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00129 
00130     sprintf(name,"h%sPosMinusNegDcaXYPrPtZFD",type[i]);
00131     dca[i].hPosMinusNegPrPtZFD =
00132       new TH3D(name,name,
00133                nVertexZWideBin,vertexZWideMin,vertexZWideMax,
00134                nPhiBin,phiDegMin,phiDegMax,
00135                nDcaXYGlBin,dcaXYGlMin,dcaXYGlMax);
00136   }
00137 
00138 }
00139 
00140 //_____________________
00141 
00142 void 
00143 StDcaAnalysis::trackLoop()
00144 {
00145   if(mDebug)
00146     cout << "StDcaAnalysis::trackLoop()" << endl;
00147 
00148   //
00149   // event stuff
00150   // 
00151   /*
00152   Float_t zdcSum = mHiMicroEvent->ZDCe() + mHiMicroEvent->ZDCw();
00153   Float_t ctb    = mHiMicroEvent->CTB();
00154   Float_t flowCent   = mHiMicroEvent->Centrality();
00155   NchCentrality zdcCent = centrality(zdcSum,ctb);
00156   */
00157 
00158   Int_t nTrack = mHiMicroEvent->NTrack();
00159   StHiMicroTrack* track;
00160   
00161   for(Int_t i=0; i<nTrack; i++){
00162     track =(StHiMicroTrack*) mHiMicroEvent->tracks()->At(i);
00163 
00164     Float_t vertexZ = mHiMicroEvent->VertexZ();
00165     Float_t dcaXYGl = track->DcaXYGl();
00166     Int_t charge = track->Charge();
00167     Float_t phiGlDeg = track->PhiGl()*180./M_PI;
00168     phiGlDeg = (phiGlDeg<-165) ? (phiGlDeg += 360) : phiGlDeg;
00169     Float_t eta  = track->EtaPr();
00170 
00171     Float_t z = vertexZ;
00172 
00173     //Float_t exitZ = vtxZ+200*TMath::Tan(track->DipAnglePr());
00174 
00175     if(!CutRc::AcceptTrackVtxZHalf(track,vertexZ)) continue;
00176 
00177     if(!CutRc::AcceptFitPts(track)) continue;
00178     if(fabs(eta)>.1) continue;
00179 
00180     mNHiPtTrack++;
00181 
00182     if(track->PtGl() >1.7 && track->PtGl()<6){ // glpt
00183       if(charge>0){ //pos
00184         dca[MEAN].hPosGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl);
00185         dca[RMS].hPosGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00186         dca[NUM].hPosGlPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00187       }
00188       else{ //neg
00189         dca[MEAN].hNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl);
00190         dca[RMS].hNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00191         dca[NUM].hNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00192       }
00193         
00194       // both
00195       dca[MEAN].hPosPlusNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl);
00196       dca[RMS].hPosPlusNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00197       dca[NUM].hPosPlusNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00198     
00199       dca[MEAN].hPosMinusNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*charge);
00200       dca[RMS].hPosMinusNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00201       dca[NUM].hPosMinusNegGlPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00202     }
00203     if(track->PtPr()>1.7 && track->PtPr()<6){
00204       if(charge>0){ //pos
00205         dca[MEAN].hPosPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl);
00206         dca[RMS].hPosPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00207         dca[NUM].hPosPrPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00208       }
00209       else{ //neg
00210         dca[MEAN].hNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl);
00211         dca[RMS].hNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00212         dca[NUM].hNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00213       }
00214         
00215       // both
00216       dca[MEAN].hPosPlusNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl);
00217       dca[RMS].hPosPlusNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00218       dca[NUM].hPosPlusNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00219     
00220       dca[MEAN].hPosMinusNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*charge);
00221       dca[RMS].hPosMinusNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl,dcaXYGl*dcaXYGl);
00222       dca[NUM].hPosMinusNegPrPtZFD->Fill(z,phiGlDeg,dcaXYGl);
00223 
00224     }
00225 
00226     
00227   } // tracks
00228 
00229   if(mDebug)
00230     cout << "\ttracks : " << nTrack << endl;
00231 
00232 }
00233 
00234 
00235 //_______________________
00236 
00237 Bool_t
00238 StDcaAnalysis::acceptEvent(StHiMicroEvent* event)
00239 {
00240   return CutRc::Accept(event);
00241 
00242 }
00243 
00244 
00245 
00246 //_______________________
00247 
00248 // ew: east is 0, west is 1
00249 
00250 Int_t
00251 StDcaAnalysis::findSector(Float_t phi, Char_t ew)
00252 {
00253   Int_t sector=0;
00254   Float_t pi = (Float_t) TMath::Pi();
00255   Float_t sectorWidth = pi/6.;
00256 
00257   Int_t sectorWest[] = {8,7,6,5,4,3,2,1,12,11,10};
00258   Int_t sectorEast[] = {16,17,18,19,20,21,22,23,24,13,14};
00259   
00260   if(phi>=(pi-sectorWidth/2.) || phi < (-pi+sectorWidth/2.)){
00261     if(ew=='w'){
00262       sector = 9;
00263     }
00264     else if(ew=='e'){
00265       sector = 15;
00266     }
00267     else{
00268       cerr << "wrong CutRc::Half " << ew << endl;
00269       exit(1);
00270     }
00271   }
00272   else{
00273     for(int i=0; i<11; i++){
00274       if(phi>=(-pi +sectorWidth*(i+1) - sectorWidth/2.) && 
00275          phi<(-pi +sectorWidth*(i+1) + sectorWidth/2.)){
00276         
00277         if(ew=='w') sector = sectorWest[i];
00278         else if(ew=='e') sector = sectorEast[i];
00279         
00280         break;
00281       }
00282     }
00283   }
00284   //  if(gRandom->Rndm()<.1)
00285   //   cout << "phi : " << phi*180./pi << " sector : " << sector << endl;
00286 
00287 
00288   if(!sector){
00289     cerr << "Huh? phi = " << phi << endl; exit(1);
00290   }
00291 
00292   return sector;
00293 }
00294 
00295 //_____________________________________
00296 
00297 ClassImp(StDcaAnalysis)