PWGHF/correlationHF/AliHFAssociatedTrackCuts.cxx

   1 /**************************************************************************\r
   2  * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *\r
   3  *                                                                        *\r
   4  * Author: The ALICE Off-line Project.                                    *\r
   5  * Contributors are mentioned in the code where appropriate.              *\r
   6  *                                                                        *\r
   7  * Permission to use, copy, modify and distribute this software and its   *\r
   8  * documentation strictly for non-commercial purposes is hereby granted   *\r
   9  * without fee, provided that the above copyright notice appears in all   *\r
  10  * copies and that both the copyright notice and this permission notice   *\r
  11  * appear in the supporting documentation. The authors make no claims     *\r
  12  * about the suitability of this software for any purpose. It is          *\r
  13  * provided "as is" without express or implied warranty.                  *\r
  14  **************************************************************************/\r
  15 \r
  16 /* $Id$ */\r
  17 \r
  18 ////////////////////////////////////////////////////////////////////////\r
  19 //\r
  20 // Base class for cuts on Associated tracks for HF Correlation analysis\r
  21 //\r
  22 // Author: S.Bjelogrlic (Utrecht) sandro.bjelogrlic@cern.ch\r
  23 ////////////////////////////////////////////////////////////////////////\r
  24 #include <Riostream.h>\r
  25 #include "AliHFAssociatedTrackCuts.h"\r
  26 #include "AliAODPidHF.h"\r
  27 #include "AliESDtrackCuts.h"\r
  28 #include "AliESDtrack.h"\r
  29 #include "AliESDVertex.h"\r
  30 #include "AliAODv0.h"\r
  31 #include "AliAODVertex.h"\r
  32 #include "AliAODMCParticle.h"\r
  33 #include "AliAnalysisManager.h"\r
  34 #include "AliInputEventHandler.h"\r
  35 #include "TString.h"\r
  36 \r
  37 using std::cout;\r
  38 using std::endl;\r
  39 \r
  40 ClassImp(AliHFAssociatedTrackCuts)\r
  41 \r
  42 //--------------------------------------------------------------------------\r
  43 AliHFAssociatedTrackCuts::AliHFAssociatedTrackCuts():\r
  44 AliAnalysisCuts(),\r
  45 fESDTrackCuts(0),\r
  46 fPidObj(0),\r
  47   fEffWeights(0),\r
  48 \r
  49 fTrigEffWeightsvspt(0),\r
  50 fTrigEffWeightsvsptB(0),\r
  51 fTrigEffWeights(0),\r
  52 fTrigEffWeightsB(0),\r
  53 fPoolMaxNEvents(0), \r
  54 fPoolMinNTracks(0), \r
  55 fMinEventsToMix(0),\r
  56 fNzVtxBins(0), \r
  57 fNzVtxBinsDim(0), \r
  58 fZvtxBins(0), \r
  59 fNCentBins(0), \r
  60 fNCentBinsDim(0), \r
  61 fCentBins(0),\r
  62 \r
  63 fNofMCEventType(0),\r
  64 fMCEventType(0),\r
  65 \r
  66 fNTrackCuts(0),\r
  67 fAODTrackCuts(0),\r
  68 fTrackCutsNames(0),\r
  69 fNvZeroCuts(0),\r
  70 fAODvZeroCuts(0),\r
  71 fvZeroCutsNames(0),\r
  72 fBit(-1),\r
  73 fCharge(0),\r
  74 fDescription("")\r
  75 \r
  76 {\r
  77         //\r
  78         //default constructor\r
  79         //\r
  80         //\r
  81         //default constructor\r
  82         //\r
  83         \r
  84 }\r
  85 \r
  86 //--------------------------------------------------------------------------\r
  87 AliHFAssociatedTrackCuts::AliHFAssociatedTrackCuts(const char* name, const char* title):\r
  88 AliAnalysisCuts(name,title),\r
  89 fESDTrackCuts(0),\r
  90 fPidObj(0),\r
  91 fEffWeights(0),\r
  92 fTrigEffWeightsvspt(0),\r
  93 fTrigEffWeightsvsptB(0),\r
  94 fTrigEffWeights(0),\r
  95 fTrigEffWeightsB(0),\r
  96 fPoolMaxNEvents(0), \r
  97 fPoolMinNTracks(0), \r
  98 fMinEventsToMix(0),\r
  99 fNzVtxBins(0), \r
 100 fNzVtxBinsDim(0), \r
 101 fZvtxBins(0), \r
 102 fNCentBins(0), \r
 103 fNCentBinsDim(0), \r
 104 fCentBins(0),\r
 105 \r
 106 fNofMCEventType(0),\r
 107 fMCEventType(0),\r
 108 \r
 109 fNTrackCuts(0),\r
 110 fAODTrackCuts(0),\r
 111 fTrackCutsNames(0),\r
 112 fNvZeroCuts(0),\r
 113 fAODvZeroCuts(0),\r
 114 fvZeroCutsNames(0),\r
 115 fBit(-1),\r
 116 fCharge(0),\r
 117 fDescription("")\r
 118 \r
 119 {\r
 120         //\r
 121         //default constructor\r
 122         //\r
 123         \r
 124 }\r
 125 //--------------------------------------------------------------------------\r
 126 AliHFAssociatedTrackCuts::AliHFAssociatedTrackCuts(const AliHFAssociatedTrackCuts &source) :\r
 127 AliAnalysisCuts(source),\r
 128 fESDTrackCuts(source.fESDTrackCuts),\r
 129 fPidObj(source.fPidObj),\r
 130 fEffWeights(source.fEffWeights),\r
 131 fTrigEffWeightsvspt(source.fTrigEffWeightsvspt),\r
 132 fTrigEffWeightsvsptB(source.fTrigEffWeightsvsptB),\r
 133 fTrigEffWeights(source.fTrigEffWeights),\r
 134 fTrigEffWeightsB(source.fTrigEffWeightsB),\r
 135 \r
 136 fPoolMaxNEvents(source.fPoolMaxNEvents), \r
 137 fPoolMinNTracks(source.fPoolMinNTracks), \r
 138 fMinEventsToMix(source.fMinEventsToMix),\r
 139 fNzVtxBins(source.fNzVtxBins), \r
 140 fNzVtxBinsDim(source.fNzVtxBinsDim), \r
 141 fZvtxBins(source.fZvtxBins), \r
 142 fNCentBins(source.fNCentBins), \r
 143 fNCentBinsDim(source.fNCentBinsDim), \r
 144 fCentBins(source.fCentBins),\r
 145 \r
 146 fNofMCEventType(source.fNofMCEventType),\r
 147 fMCEventType(source.fMCEventType),\r
 148 \r
 149 fNTrackCuts(source.fNTrackCuts),\r
 150 fAODTrackCuts(source.fAODTrackCuts),\r
 151 fTrackCutsNames(source.fTrackCutsNames),\r
 152 fNvZeroCuts(source.fNvZeroCuts),\r
 153 fAODvZeroCuts(source.fAODvZeroCuts),\r
 154 fvZeroCutsNames(source.fvZeroCutsNames),\r
 155 fBit(source.fBit),\r
 156 fCharge(source.fCharge),\r
 157 fDescription(source.fDescription)\r
 158 {\r
 159         //\r
 160         // copy constructor\r
 161         //\r
 162         \r
 163 \r
 164         AliInfo("AliHFAssociatedTrackCuts::Copy constructor ");\r
 165         if(source.fESDTrackCuts) AddTrackCuts(source.fESDTrackCuts);\r
 166         if(source.fAODTrackCuts) SetAODTrackCuts(source.fAODTrackCuts);\r
 167         if(source.fAODvZeroCuts) SetAODvZeroCuts(source.fAODvZeroCuts);\r
 168         if(source.fPidObj) SetPidHF(source.fPidObj);\r
 169         if(source.fEffWeights) SetEfficiencyWeightMap(source.fEffWeights);\r
 170         if(source.fTrigEffWeightsvspt) SetTriggerEffWeightMapvspt(source.fTrigEffWeightsvspt);\r
 171         if(source.fTrigEffWeightsvsptB) SetTriggerEffWeightMapvsptB(source.fTrigEffWeightsvsptB);\r
 172         if(source.fTrigEffWeights) SetTriggerEffWeightMap(source.fTrigEffWeights);\r
 173         if(source.fTrigEffWeightsB)SetTriggerEffWeightMapB(source.fTrigEffWeightsB);\r
 174    \r
 175     \r
 176 }\r
 177 //--------------------------------------------------------------------------\r
 178 AliHFAssociatedTrackCuts &AliHFAssociatedTrackCuts::operator=(const AliHFAssociatedTrackCuts &source)\r
 179 {\r
 180         //\r
 181         // assignment operator\r
 182         //      \r
 183         if(&source == this) return *this;\r
 184         \r
 185         AliAnalysisCuts::operator=(source);\r
 186         fESDTrackCuts=source.fESDTrackCuts;\r
 187         fPidObj=source.fPidObj;\r
 188         fEffWeights=source.fEffWeights;\r
 189     fTrigEffWeightsvspt=source.fTrigEffWeightsvspt;\r
 190         fTrigEffWeightsvsptB=source.fTrigEffWeightsvsptB;\r
 191     fTrigEffWeights=source.fTrigEffWeights;\r
 192         fTrigEffWeightsB=source.fTrigEffWeightsB;\r
 193         fNTrackCuts=source.fNTrackCuts;\r
 194         fAODTrackCuts=source.fAODTrackCuts;\r
 195         fTrackCutsNames=source.fTrackCutsNames;\r
 196         fNvZeroCuts=source.fNvZeroCuts;\r
 197         fAODvZeroCuts=source.fAODvZeroCuts;\r
 198         fvZeroCutsNames=source.fvZeroCutsNames;\r
 199         fBit=source.fBit;\r
 200         fCharge=source.fCharge;\r
 201         \r
 202         return *this;\r
 203 \r
 204 }\r
 205 \r
 206 \r
 207 //--------------------------------------------------------------------------\r
 208 AliHFAssociatedTrackCuts::~AliHFAssociatedTrackCuts()\r
 209 {\r
 210         if(fESDTrackCuts) {delete fESDTrackCuts; fESDTrackCuts = 0;}\r
 211         if(fPidObj) {delete fPidObj; fPidObj = 0;}\r
 212         if(fEffWeights){delete fEffWeights;fEffWeights=0;}\r
 213     if(fTrigEffWeightsvspt){delete fTrigEffWeightsvspt;fTrigEffWeightsvspt=0;}\r
 214         if(fTrigEffWeightsvsptB){delete fTrigEffWeightsvsptB;fTrigEffWeightsvsptB=0;}\r
 215     if(fTrigEffWeights){delete fTrigEffWeights;fTrigEffWeights=0;}\r
 216         if(fTrigEffWeightsB){delete fTrigEffWeightsB;fTrigEffWeightsB=0;}\r
 217         if(fZvtxBins) {delete[] fZvtxBins; fZvtxBins=0;} \r
 218         if(fCentBins) {delete[] fCentBins; fCentBins=0;}\r
 219         if(fAODTrackCuts) {delete[] fAODTrackCuts; fAODTrackCuts=0;}\r
 220         if(fTrackCutsNames) {delete[] fTrackCutsNames; fTrackCutsNames=0;}\r
 221         if(fAODvZeroCuts){delete[] fAODvZeroCuts; fAODvZeroCuts=0;}\r
 222         if(fvZeroCutsNames) {delete[] fvZeroCutsNames; fvZeroCutsNames=0;}\r
 223 \r
 224         \r
 225 }\r
 226 //--------------------------------------------------------------------------\r
 227 Bool_t AliHFAssociatedTrackCuts::IsInAcceptance()\r
 228 {\r
 229         printf("Careful: method AliHFAssociatedTrackCuts::IsInAcceptance is not implemented yet \n");\r
 230         return kFALSE;\r
 231 }\r
 232 //--------------------------------------------------------------------------\r
 233 Bool_t AliHFAssociatedTrackCuts::IsHadronSelected(AliAODTrack * track,const AliESDVertex *primary,const Double_t magfield)\r
 234 {\r
 235   \r
 236   AliESDtrack esdtrack(track);\r
 237   if(primary){// needed to calculate impact parameters\r
 238     // needed to calculate the impact parameters\r
 239     esdtrack.RelateToVertex(primary,magfield,3.); \r
 240   }\r
 241   // set the TPC cluster info\r
 242   esdtrack.SetTPCClusterMap(track->GetTPCClusterMap());\r
 243   esdtrack.SetTPCSharedMap(track->GetTPCSharedMap());\r
 244   esdtrack.SetTPCPointsF(track->GetTPCNclsF());\r
 245   \r
 246   if(!fESDTrackCuts->IsSelected(&esdtrack)) return kFALSE;\r
 247   \r
 248   if(fBit>-1 && !track->TestFilterBit(fBit)) return kFALSE; // check the filter bit\r
 249   \r
 250   return kTRUE;\r
 251         \r
 252 }\r
 253 \r
 254 //--------------------------------------------------------------------------\r
 255 Bool_t AliHFAssociatedTrackCuts::CheckHadronKinematic(Double_t pt, Double_t d0) \r
 256 {\r
 257         \r
 258         \r
 259         \r
 260         if(pt < fAODTrackCuts[0]) return kFALSE;\r
 261         if(pt > fAODTrackCuts[1]) return kFALSE;\r
 262         if(d0 < fAODTrackCuts[2]) return kFALSE;\r
 263         if(d0 > fAODTrackCuts[3]) return kFALSE;\r
 264         \r
 265         return kTRUE;\r
 266 \r
 267         \r
 268 }\r
 269 //--------------------------------------------------------------------------\r
 270 \r
 271 Bool_t AliHFAssociatedTrackCuts::Charge(Short_t charge, AliAODTrack* track) \r
 272 {// charge is the charge to compare to (for example, a daughter of a D meson)\r
 273         \r
 274         if(!fCharge) return kTRUE; // if fCharge is set to 0 (no selection on the charge), returns always true\r
 275         if(track->Charge()!= fCharge*charge) return kFALSE;\r
 276         return kTRUE;\r
 277 }\r
 278 \r
 279 //--------------------------------------------------------------------------\r
 280 Bool_t AliHFAssociatedTrackCuts::CheckKaonCompatibility(AliAODTrack * track, Bool_t useMc, TClonesArray* mcArray, Int_t method)\r
 281 {\r
 282         Bool_t isKaon = kFALSE;\r
 283         \r
 284         if(useMc) { // on MC\r
 285                 Int_t hadLabel = track->GetLabel();\r
 286                 if(hadLabel < 0) return kFALSE;\r
 287                 AliAODMCParticle* hadron = dynamic_cast<AliAODMCParticle*>(mcArray->At(hadLabel)); \r
 288                 if(hadron){\r
 289                   Int_t pdg = TMath::Abs(hadron->GetPdgCode()); \r
 290                   if (pdg == 321) isKaon = kTRUE;\r
 291                 }\r
 292         }\r
 293         \r
 294         if(!useMc) { // on DATA\r
 295           switch(method) {\r
 296           case(1): {\r
 297                 Bool_t isKTPC=kFALSE;\r
 298                 Bool_t isPiTPC=kFALSE;\r
 299                 Bool_t isPTPC=kFALSE;\r
 300                 Bool_t isKTOF=kFALSE;\r
 301                 Bool_t isPiTOF=kFALSE;\r
 302                 Bool_t isPTOF=kFALSE;\r
 303                 \r
 304                 Bool_t KaonHyp = kFALSE;\r
 305                 Bool_t PionHyp = kFALSE;\r
 306                 Bool_t ProtonHyp = kFALSE;\r
 307                 \r
 308                 if(fPidObj->CheckStatus(track,"TOF")) {\r
 309                         isKTOF=fPidObj->IsKaonRaw(track,"TOF");\r
 310                         isPiTOF=fPidObj->IsPionRaw(track,"TOF");\r
 311                         isPTOF=fPidObj->IsProtonRaw(track,"TOF");\r
 312                 }\r
 313                 if(fPidObj->CheckStatus(track,"TPC")){\r
 314                         isKTPC=fPidObj->IsKaonRaw(track,"TPC");\r
 315                         isPiTPC=fPidObj->IsPionRaw(track,"TPC");\r
 316                         isPTPC=fPidObj->IsProtonRaw(track,"TPC");               \r
 317                 }\r
 318                 \r
 319                 if (isKTOF && isKTPC) KaonHyp = kTRUE;\r
 320                 if (isPiTOF && isPiTPC) PionHyp = kTRUE;\r
 321                 if (isPTOF && isPTPC) ProtonHyp = kTRUE;\r
 322                 \r
 323                 if(KaonHyp && !PionHyp && !ProtonHyp) isKaon = kTRUE; \r
 324                 break;\r
 325               }\r
 326       case(2): {\r
 327                 if(fPidObj->MakeRawPid(track,3)>=1) isKaon = kTRUE;\r
 328                 break;\r
 329               }\r
 330       }\r
 331         }\r
 332         \r
 333         return isKaon;\r
 334         \r
 335 }\r
 336 //--------------------------------------------------------------------------\r
 337 Bool_t AliHFAssociatedTrackCuts::IsKZeroSelected(AliAODv0 *vzero, AliAODVertex *vtx1)\r
 338 {\r
 339         \r
 340         if(vzero->DcaV0Daughters()>fAODvZeroCuts[0]) return kFALSE;\r
 341         if(vzero->Chi2V0()>fAODvZeroCuts[1]) return kFALSE;\r
 342         if(vzero->DecayLength(vtx1) < fAODvZeroCuts[2]) return kFALSE;\r
 343         if(vzero->DecayLength(vtx1) > fAODvZeroCuts[3]) return kFALSE;\r
 344         if(vzero->OpenAngleV0() > fAODvZeroCuts[4]) return kFALSE;\r
 345         if(vzero->Pt() < fAODvZeroCuts[5]) return kFALSE;\r
 346         if(TMath::Abs(vzero->Eta()) > fAODvZeroCuts[6]) return kFALSE;\r
 347 \r
 348         \r
 349         return kTRUE;\r
 350 }\r
 351 //--------------------------------------------------------------------------\r
 352 Bool_t *AliHFAssociatedTrackCuts::IsMCpartFromHF(Int_t label, TClonesArray*mcArray){\r
 353   // Check origin in MC\r
 354 \r
 355   AliAODMCParticle* mcParticle;\r
 356   Int_t pdgCode = -1;\r
 357         \r
 358   Bool_t isCharmy = kFALSE;\r
 359   Bool_t isBeauty = kFALSE;\r
 360   Bool_t isD = kFALSE;\r
 361   Bool_t isB = kFALSE;\r
 362     \r
 363      Bool_t *originvect = new Bool_t[4];\r
 364     \r
 365     originvect[0] = kFALSE;\r
 366         originvect[1] = kFALSE;\r
 367         originvect[2] = kFALSE;\r
 368         originvect[3] = kFALSE;\r
 369 \r
 370         if (label<0) return originvect;\r
 371   \r
 372         while(pdgCode!=2212){ // loops back to the collision to check the particle source\r
 373 \r
 374     mcParticle = dynamic_cast<AliAODMCParticle*>(mcArray->At(label));\r
 375     if(!mcParticle) {AliError("NO MC PARTICLE"); break;}\r
 376     pdgCode =  TMath::Abs(mcParticle->GetPdgCode());\r
 377 \r
 378     label = mcParticle->GetMother();\r
 379 \r
 380 \r
 381     if((pdgCode>=400 && pdgCode <500) || (pdgCode>=4000 && pdgCode<5000 )) isD = kTRUE;\r
 382     if((pdgCode>=500 && pdgCode <600) || (pdgCode>=5000 && pdgCode<6000 )) {isD = kFALSE; isB = kTRUE;}\r
 383 \r
 384 \r
 385     if(pdgCode == 4) isCharmy = kTRUE;\r
 386     if(pdgCode == 5) {isBeauty = kTRUE; isCharmy = kFALSE;}\r
 387     if(label<0) break;\r
 388 \r
 389   }\r
 390 \r
 391         \r
 392         originvect[0] = isCharmy;\r
 393         originvect[1] = isBeauty;\r
 394         originvect[2] = isD;\r
 395         originvect[3] = isB;\r
 396  \r
 397     \r
 398   return originvect;\r
 399 }\r
 400 \r
 401 //--------------------------------------------------------------------------\r
 402 Bool_t AliHFAssociatedTrackCuts::InvMassDstarRejection(AliAODRecoDecayHF2Prong* d, AliAODTrack *track, Int_t hypD0) const {\r
 403         //\r
 404         // Calculates invmass of track+D0 and rejects if compatible with D*\r
 405         // (to remove pions from D*)\r
 406         // \r
 407         Double_t nsigma = 3.;\r
 408         \r
 409         Double_t mD0, mD0bar;\r
 410         d->InvMassD0(mD0,mD0bar);\r
 411         \r
 412         Double_t invmassDstar1 = 0, invmassDstar2 = 0; \r
 413         Double_t e1Pi = d->EProng(0,211), e2K = d->EProng(1,321); //hyp 1 (pi,K) - D0\r
 414         Double_t e1K = d->EProng(0,321), e2Pi = d->EProng(1,211); //hyp 2 (K,pi) - D0bar\r
 415         Double_t psum2 = (d->Px()+track->Px())*(d->Px()+track->Px())\r
 416         +(d->Py()+track->Py())*(d->Py()+track->Py())\r
 417         +(d->Pz()+track->Pz())*(d->Pz()+track->Pz());\r
 418         \r
 419         switch(hypD0) {\r
 420                 case 1:\r
 421                         invmassDstar1 = TMath::Sqrt(pow(e1Pi+e2K+track->E(0.1396),2.)-psum2);\r
 422                         if ((TMath::Abs(invmassDstar1-mD0)-0.14543) < nsigma*800.*pow(10.,-6.)) return kFALSE;\r
 423                         break;\r
 424                 case 2:\r
 425                         invmassDstar2 = TMath::Sqrt(pow(e2Pi+e1K+track->E(0.1396),2.)-psum2);\r
 426                         if ((TMath::Abs(invmassDstar2-mD0bar)-0.14543) < nsigma*800.*pow(10.,-6.)) return kFALSE;\r
 427                         break;\r
 428                 case 3:\r
 429                         invmassDstar1 = TMath::Sqrt(pow(e1Pi+e2K+track->E(0.1396),2.)-psum2);\r
 430                         invmassDstar2 = TMath::Sqrt(pow(e2Pi+e1K+track->E(0.1396),2.)-psum2);\r
 431                         if ((TMath::Abs(invmassDstar1-mD0)-0.14543) < nsigma*800.*pow(10.,-6.)) return kFALSE;\r
 432                         if ((TMath::Abs(invmassDstar2-mD0bar)-0.14543) < nsigma*800.*pow(10.,-6.)) return kFALSE;\r
 433                         break;\r
 434         }\r
 435         \r
 436         return kTRUE;\r
 437 }\r
 438 //________________________________________________________\r
 439 void AliHFAssociatedTrackCuts::SetMCEventTypes(Int_t *MCEventTypeArray)\r
 440 // set the array of event types you want to process in MonteCarlo (gluon splitting, pair production etc.)\r
 441 {\r
 442         if(!fMCEventType) fMCEventType = new Int_t[fNofMCEventType];\r
 443         \r
 444         for(Int_t k=0; k<fNofMCEventType; k++){\r
 445                 fMCEventType[k] = MCEventTypeArray[k];\r
 446         }\r
 447         return; \r
 448 }\r
 449 \r
 450 //________________________________________________________\r
 451 void AliHFAssociatedTrackCuts::SetAODTrackCuts(Float_t *cutsarray)\r
 452 {\r
 453         if(!fAODTrackCuts) fAODTrackCuts = new Float_t[fNTrackCuts];\r
 454         for(Int_t i =0; i<fNTrackCuts; i++){\r
 455                 fAODTrackCuts[i] = cutsarray[i];\r
 456         }\r
 457         SetTrackCutsNames();\r
 458         return;\r
 459 }\r
 460 //________________________________________________________\r
 461 void AliHFAssociatedTrackCuts::SetTrackCutsNames(/*TString *namearray*/){\r
 462         \r
 463         fTrackCutsNames = new TString[4];\r
 464         fTrackCutsNames[0]= "associated track:: pt min [GeV/c]................: ";\r
 465         fTrackCutsNames[1]= "associated track:: pt max [GeV/c]................: ";\r
 466         fTrackCutsNames[2]= "associated track:: d0 min [cm]...................: ";\r
 467         fTrackCutsNames[3]= "associated track:: d0 max [cm]...................: ";\r
 468         \r
 469 \r
 470         \r
 471         return;\r
 472 }\r
 473 //--------------------------------------------------------------------------\r
 474 void AliHFAssociatedTrackCuts::SetAODvZeroCuts(Float_t *cutsarray)\r
 475 {\r
 476         \r
 477 \r
 478         if(!fAODvZeroCuts) fAODvZeroCuts = new Float_t[fNvZeroCuts];\r
 479         for(Int_t i =0; i<fNvZeroCuts; i++){\r
 480                 fAODvZeroCuts[i] = cutsarray[i];\r
 481         }\r
 482         SetvZeroCutsNames();\r
 483         return;\r
 484 }\r
 485 //--------------------------------------------------------------------------\r
 486 void AliHFAssociatedTrackCuts::SetvZeroCutsNames(/*TString *namearray*/){\r
 487         \r
 488         fvZeroCutsNames = new TString[7];\r
 489         fvZeroCutsNames[0] = "vZero:: max DCA between two daughters [cm].......: ";\r
 490         fvZeroCutsNames[1] = "vZero:: max fit Chi Square between two daughters.: ";\r
 491         fvZeroCutsNames[2] = "vZero:: min decay length [cm]....................: ";\r
 492         fvZeroCutsNames[3] = "vZero:: max decay length [cm]....................: ";\r
 493         fvZeroCutsNames[4] = "vZero:: max opening angle between daughters [rad]: ";\r
 494         fvZeroCutsNames[5] = "vZero:: pt min [Gev/c]...........................: ";\r
 495         fvZeroCutsNames[6] = "vZero:: |Eta| range <............................: ";\r
 496         \r
 497         \r
 498         return;\r
 499 }\r
 500 \r
 501 //--------------------------------------------------------------------------\r
 502 void AliHFAssociatedTrackCuts::SetPidAssociated()\r
 503 {\r
 504   //setting PidResponse\r
 505   if(fPidObj->GetOldPid()==kFALSE && fPidObj->GetPidResponse()==0x0){\r
 506     AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
 507     AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();\r
 508     AliPIDResponse *pidResp=inputHandler->GetPIDResponse();\r
 509     fPidObj->SetPidResponse(pidResp);\r
 510   }\r
 511 }\r
 512 //--------------------------------------------------------------------------\r
 513 \r
 514 void AliHFAssociatedTrackCuts::Print(Option_t *option) const\r
 515 {\r
 516   /// overloaded from TObject: print info\r
 517   if (strcmp(option, "parameters")==0) {\r
 518     PrintPoolParameters();\r
 519     return;\r
 520   } else if (strcmp(option, "selectedMC")==0) {\r
 521     PrintSelectedMCevents();\r
 522     return;\r
 523   }\r
 524   PrintAll();\r
 525 }\r
 526 \r
 527 //--------------------------------------------------------------------------\r
 528 Int_t AliHFAssociatedTrackCuts::GetPoolBin(Double_t multorcent, Double_t zVtx) const\r
 529 {\r
 530  \r
 531     Int_t poolbin = -1;\r
 532     Int_t centbin = -1;\r
 533     Int_t zvtxbin = -1;\r
 534     \r
 535     \r
 536     if(multorcent <fCentBins[0]) return poolbin;\r
 537     if(zVtx <fZvtxBins[0]) return poolbin;\r
 538     \r
 539     \r
 540     for (Int_t i=0;i<fNCentBins;i++){\r
 541         if(multorcent<fCentBins[i+1]) {\r
 542             centbin=i;\r
 543             break;\r
 544         }\r
 545     }\r
 546     \r
 547     for (Int_t i=0;i<fNzVtxBins;i++){\r
 548         if(zVtx<fZvtxBins[i+1]) {\r
 549             zvtxbin=i;\r
 550             break;\r
 551         }\r
 552     }\r
 553 \r
 554     poolbin = centbin  + zvtxbin*fNzVtxBins;\r
 555     \r
 556     return poolbin;\r
 557 }\r
 558 //--------------------------------------------------------------------------\r
 559 void AliHFAssociatedTrackCuts::PrintAll() const\r
 560 {\r
 561         \r
 562         if(fDescription){\r
 563           printf("=================================================");\r
 564           printf("\nAdditional description\n");\r
 565           std::cout << fDescription << std::endl;\r
 566           printf("\n");\r
 567         }\r
 568         printf("\n=================================================");\r
 569         if(fESDTrackCuts){\r
 570           printf("\nCuts for the associated track: \n \n");\r
 571           \r
 572           printf("ITS Refit........................................: %s\n",fESDTrackCuts->GetRequireITSRefit() ? "Yes" : "No");\r
 573           printf("TPC Refit........................................: %s\n",fESDTrackCuts->GetRequireTPCRefit() ? "Yes" : "No");\r
 574           printf("ITS SA...........................................: %s\n",fESDTrackCuts->GetRequireITSStandAlone() ? "Yes" : "No");\r
 575           printf("TPC SA...........................................: %s\n",fESDTrackCuts->GetRequireTPCStandAlone() ? "Yes" : "No");\r
 576           printf("Min number of ITS clusters.......................: %d\n",fESDTrackCuts->GetMinNClustersITS());\r
 577           printf("Min number of TPC clusters.......................: %d\n",fESDTrackCuts->GetMinNClusterTPC());\r
 578           Int_t spd = fESDTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD);\r
 579           if(spd==0) std::cout <<  "SPD..............................................: kOff"  << std::endl;\r
 580           if(spd==1) std::cout <<  "SPD..............................................: kNone"  << std::endl;\r
 581           if(spd==2) std::cout <<  "SPD..............................................: kAny"  << std::endl;\r
 582           if(spd==3) std::cout <<  "SPD..............................................: kFirst"  << std::endl;\r
 583           if(spd==4) std::cout <<  "SPD..............................................: kOnlyFirst"  << std::endl;\r
 584           if(spd==5) std::cout <<  "SPD..............................................: kSecond"  << std::endl;\r
 585           if(spd==6) std::cout <<  "SPD..............................................: kOnlySecond"  << std::endl;\r
 586           if(spd==7) std::cout <<  "SPD..............................................: kBoth"  << std::endl;\r
 587         }\r
 588         else printf("\nNo Cuts for Associated Tracks\n");\r
 589         std::cout <<  "Filter Bit.......................................: " << fBit  << std::endl;\r
 590         std::cout <<  "Charge...........................................: " << fCharge  << std::endl;\r
 591         \r
 592         if(fAODTrackCuts){\r
 593           for(Int_t j=0;j<fNTrackCuts;j++){\r
 594             std::cout << fTrackCutsNames[j] << fAODTrackCuts[j] << std::endl;\r
 595           }\r
 596         }\r
 597 \r
 598         if(fAODvZeroCuts){\r
 599           printf("\n");\r
 600           printf("=================================================");\r
 601           printf("\nCuts for the K0 candidates: \n \n");\r
 602           for(Int_t k=0;k<fNvZeroCuts;k++){\r
 603             std::cout << fvZeroCutsNames[k] <<  fAODvZeroCuts[k] << std::endl;\r
 604           }\r
 605         }\r
 606         else printf("\nNo Cuts for the K0 candidates\n");\r
 607         std::cout << " " << std::endl;\r
 608         PrintPoolParameters();\r
 609         PrintSelectedMCevents();\r
 610 \r
 611 }\r
 612 \r
 613 //--------------------------------------------------------------------------\r
 614 void AliHFAssociatedTrackCuts::PrintPoolParameters() const\r
 615 {   \r
 616         printf("=================================================");\r
 617         printf("\nEvent Pool settings: \n \n");\r
 618         \r
 619         printf("Number of zVtx Bins: %d\n", fNzVtxBins);\r
 620         printf("\nzVtx Bins:\n");\r
 621         //Double_t zVtxbinLims[fNzVtxBins+1] = fNzVtxBins;\r
 622         for(Int_t k=0; k<fNzVtxBins; k++){\r
 623                 printf("Bin %d..............................................: %.1f - %.1f cm\n", k, fZvtxBins[k], fZvtxBins[k+1]);      \r
 624         }\r
 625         printf("\n");\r
 626         printf("\nNumber of Centrality(multiplicity) Bins: %d\n", fNCentBins);\r
 627         printf("\nCentrality(multiplicity) Bins:\n");\r
 628         for(Int_t k=0; k<fNCentBins; k++){\r
 629                 printf("Bin %d..............................................: %.1f - %.1f\n", k, fCentBins[k], fCentBins[k+1]);\r
 630         }\r
 631 \r
 632         \r
 633         \r
 634 }\r
 635 //--------------------------------------------------------------------------\r
 636 \r
 637 Double_t AliHFAssociatedTrackCuts::GetTrackWeight(Double_t pt, Double_t eta,Double_t zvtx){\r
 638   if(!fEffWeights)return 1.;\r
 639   \r
 640   Int_t bin=fEffWeights->FindBin(pt,eta,zvtx);\r
 641   if(fEffWeights->IsBinUnderflow(bin)||fEffWeights->IsBinOverflow(bin))return 1.;\r
 642   return fEffWeights->GetBinContent(bin);\r
 643 \r
 644 }\r
 645 \r
 646 \r
 647 //--------------------------------------------------------------------------\r
 648 Double_t AliHFAssociatedTrackCuts::GetTrigWeight(Double_t pt, Double_t mult){\r
 649     \r
 650     \r
 651     \r
 652     if(fTrigEffWeightsvspt){\r
 653        Int_t bin=fTrigEffWeightsvspt->FindBin(pt);\r
 654         if(fTrigEffWeightsvspt->IsBinUnderflow(bin)||fTrigEffWeightsvspt->IsBinOverflow(bin))return 1.;\r
 655         return fTrigEffWeightsvspt->GetBinContent(bin);\r
 656         \r
 657     }\r
 658     \r
 659     if(fTrigEffWeights){\r
 660         Int_t bin=fTrigEffWeights->FindBin(pt,mult);\r
 661         if(fTrigEffWeights->IsBinUnderflow(bin)||fTrigEffWeights->IsBinOverflow(bin))return 1.;\r
 662         return fTrigEffWeights->GetBinContent(bin);\r
 663         \r
 664     }\r
 665     \r
 666     //if(!fTrigEffWeights && !fTrigEffWeightsvspt)return 1.;\r
 667     \r
 668     return 1.;\r
 669     \r
 670 }\r
 671 \r
 672 //--------------------------------------------------------------------------\r
 673 Double_t AliHFAssociatedTrackCuts::GetTrigWeightB(Double_t pt, Double_t mult){\r
 674     \r
 675     if(fTrigEffWeightsvsptB){\r
 676         Int_t bin=fTrigEffWeightsvsptB->FindBin(pt);\r
 677         if(fTrigEffWeightsvsptB->IsBinUnderflow(bin)||fTrigEffWeightsvsptB->IsBinOverflow(bin))return 1.;\r
 678         return fTrigEffWeightsvsptB->GetBinContent(bin);\r
 679         \r
 680     }\r
 681     \r
 682     if(fTrigEffWeightsB){\r
 683         Int_t bin=fTrigEffWeightsB->FindBin(pt,mult);\r
 684         if(fTrigEffWeightsB->IsBinUnderflow(bin)||fTrigEffWeightsB->IsBinOverflow(bin))return 1.;\r
 685         return fTrigEffWeightsB->GetBinContent(bin);\r
 686         \r
 687     }\r
 688     \r
 689  //   if(!fTrigEffWeightsB && !fTrigEffWeightsvsptB)return 1.;\r
 690     return 1;\r
 691 }\r
 692 //--------------------------------------------------------------------------\r
 693 void AliHFAssociatedTrackCuts::PrintSelectedMCevents() const\r
 694 {\r
 695         printf("\n=================================================");\r
 696         \r
 697         printf("\nSelected MC events: \n \n");\r
 698         printf("Number of selected events: %d\n",fNofMCEventType);\r
 699         \r
 700         for(Int_t k=0; k<fNofMCEventType; k++){\r
 701         if(fMCEventType[k]==28) printf("=> Flavour excitation \n");     \r
 702         if(fMCEventType[k]==53) printf("=> Pair creation \n");  \r
 703         if(fMCEventType[k]==68) printf("=> Gluon splitting \n");        \r
 704         }\r
 705         \r
 706         printf("\n");\r
 707         for(Int_t k=0; k<fNofMCEventType; k++){\r
 708                 printf("MC process code %d \n",fMCEventType[k]);                \r
 709         }\r
 710         \r
 711         printf("\n");\r
 712         \r
 713         \r
 714                 \r
 715         \r
 716 }\r
 717 \r
 718 \r