PWGDQ/dielectron/AliDielectronVarContainer.h

   1 #ifndef ALIDIELECTRONVARCONTAINER_H
   2 #define ALIDIELECTRONVARCONTAINER_H
   3 /* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 //#############################################################
   7 //#                                                           #
   8 //#         Class AliDielectronVarContainer                   #
   9 //#         Class for management of available variables       #
  10 //#                                                           #
  11 //#  Authors:                                                 #
  12 //#   Anton     Andronic, GSI / A.Andronic@gsi.de             #
  13 //#   Ionut C.  Arsene,   GSI / I.C.Arsene@gsi.de             #
  14 //#   Julian    Book,     Uni Ffm / Julian.Book@cern.ch       #
  15 //#   Markus    Köhler,   GSI / M.Koehler@gsi.de              #
  16 //#   Frederick Kramer,   Uni Ffm / Frederick.Kramer@cern.ch  #
  17 //#   Magnus    Mager,    CERN / Magnus.Mager@cern.ch         #
  18 //#   WooJin J. Park,     GSI / W.J.Park@gsi.de               #
  19 //#   Jens      Wiechula, Uni HD / Jens.Wiechula@cern.ch      #
  20 //#                                                           #
  21 //#############################################################
  22
  23
  24 #include <TNamed.h>
  25 #include <TDatabasePDG.h>
  26
  27 #include <AliVEvent.h>
  28 #include <AliESDEvent.h>
  29 #include <AliAODEvent.h>
  30 #include <AliMCEvent.h>
  31 #include <AliESDVertex.h>
  32 #include <AliAODVertex.h>
  33
  34 #include <AliVParticle.h>
  35 #include <AliESDtrack.h>
  36 #include <AliAODTrack.h>
  37 #include <AliAODPid.h>
  38 #include <AliKFParticle.h>
  39 #include <AliKFVertex.h>
  40 #include <AliMCParticle.h>
  41 #include <AliAODMCParticle.h>
  42 #include <AliVTrack.h>  // ?
  43
  44 #include <AliExternalTrackParam.h>
  45 #include <AliESDpid.h>
  46 #include <AliCentrality.h>
  47 #include <AliAODpidUtil.h>
  48 #include <AliPID.h>
  49 #include <AliPIDResponse.h>
  50
  51 #include "AliDielectronPair.h"
  52 #include "AliDielectronMC.h"
  53 #include "AliDielectronPID.h"
  54 #include "AliDielectronHelper.h"
  55
  56 class AliVEvent;
  57
  58 //________________________________________________________________
  59 class AliDielectronVarContainer : public TNamed {
  60
  61 public:
  62
  63   enum ValueTypes {
  64     // Leg specific variables
  65     kPx = 0,                 // px
  66     kPy,                     // py
  67     kPz,                     // pz
  68     kPt,                     // transverse momentum
  69     kP,                      // momentum
  70     kXv,                     // vertex position in x
  71     kYv,                     // vertex position in y
  72     kZv,                     // vertex position in z
  73     kOneOverPt,              // 1/pt
  74     kPhi,                    // phi angle
  75     kTheta,                  // theta angle
  76     kEta,                    // pseudo-rapidity
  77     kY,                      // rapidity
  78     kE,                      // energy
  79     kM,                      // mass
  80     kCharge,                 // charge
  81     kNclsITS,                // number of clusters assigned in the ITS
  82     kNclsTPC,                // number of clusters assigned in the TPC
  83     kNclsTPCiter1,           // number of clusters assigned in the TPC after first iteration
  84     kNFclsTPC,               // number of findable clusters in the TPC
  85     kNFclsTPCr,              // number of findable clusters in the TPC with more robust definition
  86     kNFclsTPCrFrac,          // number of found/findable clusters in the TPC with more robust definition
  87     kTPCsignalN,             // number of points used for dEdx
  88     kTPCsignalNfrac,         // fraction of points used for dEdx / cluster used for tracking
  89     kTPCchi2Cl,              // chi2/cl in TPC
  90     kTrackStatus,            // track status bits
  91     kNclsTRD,                // number of clusters assigned in the TRD
  92     kTRDntracklets,          // number of TRD tracklets used for tracking/PID TODO: correct getter
  93     kTRDpidQuality,          // number of TRD tracklets used for PID
  94     kTRDprobEle,             // TRD electron pid probability
  95     kTRDprobPio,             // TRD electron pid probability
  96     kImpactParXY,            // Impact parameter in XY plane
  97     kImpactParZ,             // Impact parameter in Z
  98     kTrackLength,            // Track length
  99     kITSsignal,                    // ITS dE/dx signal
 100     kITSsignalSSD1,              // SSD1 dE/dx signal
 101     kITSsignalSSD2,              // SSD2 dE/dx signal
 102     kITSsignalSDD1,              // SDD1 dE/dx signal
 103     kITSsignalSDD2,              // SDD2 dE/dx signal
 104     kITSclusterMap,          // ITS cluster map
 105     kITSnSigmaEle,           // number of sigmas to the dE/dx electron line in the ITS
 106     kITSnSigmaPio,           // number of sigmas to the dE/dx pion line in the ITS
 107     kITSnSigmaMuo,           // number of sigmas to the dE/dx muon line in the ITS
 108     kITSnSigmaKao,           // number of sigmas to the dE/dx kaon line in the ITS
 109     kITSnSigmaPro,           // number of sigmas to the dE/dx proton line in the ITS
 110     kPIn,                    // momentum at inner wall of TPC (if available), used for PID
 111     kTPCsignal,              // TPC dE/dx signal
 112         kTOFsignal,              // TOF signal
 113           kTOFbeta,                // TOF beta
 114     kTPCnSigmaEle,           // number of sigmas to the dE/dx electron line in the TPC
 115     kTPCnSigmaPio,           // number of sigmas to the dE/dx pion line in the TPC
 116     kTPCnSigmaMuo,           // number of sigmas to the dE/dx muon line in the TPC
 117     kTPCnSigmaKao,           // number of sigmas to the dE/dx kaon line in the TPC
 118     kTPCnSigmaPro,           // number of sigmas to the dE/dx proton line in the TPC
 119           kTOFnSigmaEle,           // number of sigmas to the pion line in the TOF
 120     kTOFnSigmaPio,           // number of sigmas to the pion line in the TOF
 121     kTOFnSigmaMuo,           // number of sigmas to the muon line in the TOF
 122     kTOFnSigmaKao,           // number of sigmas to the kaon line in the TOF
 123     kTOFnSigmaPro,           // number of sigmas to the proton line in the TOF
 124     kKinkIndex0,             // kink index 0
 125     kParticleMax,            // TODO: kRNClusters ??
 126
 127     // Pair specific variables
 128     kChi2NDF = kParticleMax, // Chi^2/NDF
 129     kDecayLength,            // decay length
 130     kR,                      // distance to the origin
 131     kOpeningAngle,           // opening angle
 132     // Helicity picture: Z-axis is considered the direction of the mother's 3-momentum vector
 133     kThetaHE,                // theta in mother's rest frame in the helicity picture
 134     kPhiHE,                  // phi in mother's rest frame in the helicity picture
 135     // Collins-Soper picture: Z-axis is considered the direction of the vectorial difference between
 136     // the 3-mom vectors of target and projectile beams
 137     kThetaCS,                // theta in mother's rest frame in Collins-Soper picture
 138     kPhiCS,                  // phi in mother's rest frame in Collins-Soper picture
 139     kLegDist,                // distance of the legs
 140     kLegDistXY,              // distance of the legs in XY
 141     kDeltaEta,               // Absolute value of Delta Eta for the legs
 142     kDeltaPhi,               // Absolute value of Delta Phi for the legs
 143     kMerr,                   // error of mass calculation
 144     kDCA,                    // distance of closest approach TODO: not implemented yet
 145     kPairType,               // type of the pair, like like sign ++ unlikesign ...
 146     kPseudoProperTime,       // pseudo proper time
 147     kPairMax,                //
 148
 149     // Event specific variables
 150     kXvPrim = kPairMax,      // prim vertex x
 151     kYvPrim,                 // prim vertex y
 152     kZvPrim,                 // prim vertex z
 153     kXRes,                   // primary vertex x-resolution
 154     kYRes,                   // primary vertex y-resolution
 155     kZRes,                   // primary vertex z-resolution
 156     kNContrib,               // Number of vertex contributors
 157     kBzkG,                   // z componenent of field in kG
 158     kNTrk,                   // number of tracks
 159     kNacc,                   // Number of accepted tracks
 160     kNaccTrcklts,            // Number of accepted tracklets (MUON definition)
 161     kNaccTrckltsCorr,        // Number of corrected accepted tracklets (correction based on flattening the average number of tracklets as a function of event vertex)
 162     kNaccTrcklts05,          // As in kNaccTrcklts but |eta|<0.5 instead of |eta|<1.6
 163     kNaccTrcklts10,          // As in kNaccTrcklts but |eta|<1.0 instead of |eta|<1.6
 164     kNaccTrckltsEsd05,       // SPD tracklets from AliESDEvent::EstimateMultiplicity() in |eta|<0.5
 165     kNaccTrckltsEsd10,       // SPD tracklets from AliESDEvent::EstimateMultiplicity() in |eta|<1.0
 166     kNaccTrckltsEsd16,       // SPD tracklets from AliESDEvent::EstimateMultiplicity() in |eta|<1.6
 167     kNaccItsTpcEsd05,        // TPC/ITS tracks + ITS SA complementary tracks + tracklets from clusters not used in tracks from AliESDEvent::EstimateMultiplicity() in |eta|<0.5
 168     kNaccItsTpcEsd10,        // TPC/ITS tracks + ITS SA complementary tracks + tracklets from clusters not used in tracks from AliESDEvent::EstimateMultiplicity() in |eta|<1.0
 169     kNaccItsTpcEsd16,        // TPC/ITS tracks + ITS SA complementary tracks + tracklets from clusters not used in tracks from AliESDEvent::EstimateMultiplicity() in |eta|<1.6
 170     kNaccItsPureEsd05,       // ITS SA tracks + tracklets from clusters not used in tracks from AliESDEvent::EstimateMultiplicity() in |eta|<0.5
 171     kNaccItsPureEsd10,       // ITS SA tracks + tracklets from clusters not used in tracks from AliESDEvent::EstimateMultiplicity() in |eta|<1.0
 172     kNaccItsPureEsd16,       // ITS SA tracks + tracklets from clusters not used in tracks from AliESDEvent::EstimateMultiplicity() in |eta|<1.6
 173
 174
 175     kMultV0A,                // VZERO multiplicity and ADC amplitudes
 176     kMultV0C,
 177     kMultV0,
 178     kAdcV0A,
 179     kAdcV0C,
 180     kAdcV0,
 181
 182     kCentrality,             // event centrality fraction
 183     kNevents,                // event counter
 184     kNMaxValues              // TODO: (for A+A) ZDCEnergy, impact parameter, Iflag??
 185   };
 186
 187
 188   enum ValueTypesMC {
 189     // Leg specific variables
 190     kPxMC = 0,              // px
 191     kPyMC,                  // py
 192     kPzMC,                  // pz
 193     kPtMC,                  // transverse momentum
 194     kPMC,                   // momentum
 195     kXvMC,                  // vertex position in x
 196     kYvMC,                  // vertex position in y
 197     kZvMC,                  // vertex position in z
 198     kOneOverPtMC,           // 1/pt
 199     kPhiMC,                 // phi angle
 200     kThetaMC,               // theta angle
 201     kEtaMC,                 // pseudo-rapidity
 202     kYMC,                   // rapidity
 203     kEMC,                   // energy
 204     kMMC,                   // mass
 205     kChargeMC,              // charge
 206     kImpactParXYMC,         // Impact parameter in XY plane
 207     kImpactParZMC,          // Impact parameter in Z
 208     kPdgCode,                // PDG code
 209     kPdgCodeMother,          // PDG code of the mother
 210     kPdgCodeGrandMother,     // PDG code of the grand mother
 211     kNumberOfDaughters,      // number of daughters
 212     kHaveSameMother,         // check that particles have the same mother (MC)
 213     kIsJpsiPrimary,          // check if the particle is primary (MC)
 214     kParticleMaxMC,         //
 215
 216 // Pair specific variables
 217     kDecayLengthvMC = kParticleMaxMC, // decay length
 218     kRMC,                      // distance to the origin
 219     kOpeningAngleMC,           // opening angle
 220     // Helicity picture: Z-axis is considered the direction of the mother's 3-momentum vector
 221     kThetaHEMC,                // theta in mother's rest frame in the helicity picture
 222     kPhiHEMC,                  // phi in mother's rest frame in the helicity picture
 223     // Collins-Soper picture: Z-axis is considered the direction of the vectorial difference between
 224     // the 3-mom vectors of target and projectile beams
 225     kThetaCSMC,                // theta in mother's rest frame in Collins-Soper picture
 226     kPhiCSMC,                  // phi in mother's rest frame in Collins-Soper picture
 227     kLegDistMC,                // distance of the legs
 228     kLegDistXYMC,              // distance of the legs in XY
 229     kDeltaEtaMC,               // Absolute value of Delta Eta for the legs
 230     kDeltaPhiMC,               // Absolute value of Delta Phi for the legs
 231     kDCAMC,                    // distance of closest approach TODO: not implemented yet
 232     kPairTypeMC,               // type of the pair, like like sign ++ unlikesign ...
 233     kPseudoProperTimeMC,       // pseudo proper time
 234     kPairMaxMC,                //
 235
 236 // Event specific variables
 237     kXvPrimMC = kPairMaxMC,   // prim vertex x
 238     kYvPrimMC,                 // prim vertex y
 239     kZvPrimMC,                 // prim vertex z
 240     kNch,                    // Number of charged MC tracks in |eta|<1.6
 241     kNch05,                  // Number of charged MC tracks in |eta|<0.5
 242     kNch10,                  // Number of charged MC tracks in |eta|<1.0
 243     kCentralityMC,             // event centrality fraction
 244     kNeventsMC,                // event counter
 245     kNMaxValuesMC              // TODO: (for A+A) ZDCEnergy, impact parameter, Iflag??
 246   };
 247
 248
 249
 250   AliDielectronVarContainer();
 251   AliDielectronVarContainer(const char* name, const char* title);
 252   virtual ~AliDielectronVarContainer();
 253
 254   static void Fill(const TObject* object);
 255   static void InitESDpid(Int_t type=0);
 256   static void InitAODpidUtil(Int_t type=0);
 257
 258   static void SetPIDResponse(AliPIDResponse *pidResponse) { fgPIDResponse=pidResponse;                           }
 259   static void SetEvent(AliVEvent * const event); // TODO: needed?
 260
 261   static AliPIDResponse* GetPIDResponse()                 { return fgPIDResponse;                                }
 262   static const AliKFVertex* GetKFVertex()                 { return fgKFVertex;                                   }
 263   static const char* GetValueName(Int_t i)                { return (i>=0&&i<kNMaxValues)?fgkParticleNames[i]:""; }
 264   static const Double_t* GetData()                        { return fgData;                                       }
 265   static const Double_t* GetDataMC()                      { return fgDataMC;                                     }
 266   static Double_t GetValue(ValueTypes val)                { return fgData[val];                                  }
 267   static Double_t GetValueMC(ValueTypesMC val)            { return fgDataMC[val];                                }
 268   static Bool_t GetDCA(const AliAODTrack *track, Double_t d0z0[2]);
 269
 270 private:
 271
 272   static Double_t fgData[kNMaxValues];                   //! data
 273   static Double_t fgDataMC[kNMaxValuesMC];              //! MC data
 274   static const char* fgkParticleNames[kNMaxValues];      // variable names
 275   static const char* fgkParticleNamesMC[kNMaxValuesMC]; // MC variable names
 276
 277   static void FillVarVParticle(const AliVParticle *particle);
 278   static void FillVarVParticleMC(const AliVParticle *particle);
 279   static void FillVarESDtrack(const AliESDtrack *particle);
 280   static void FillVarAODTrack(const AliAODTrack *particle);
 281   static void FillVarMCParticle(const AliMCParticle *particle);
 282   static void FillVarAODMCParticle(const AliAODMCParticle *particle);
 283   static void FillVarDielectronPair(const AliDielectronPair *pair);
 284   static void FillVarKFParticle(const AliKFParticle *pair);
 285
 286   static void FillVarVEvent(const AliVEvent *event);
 287   static void FillVarESDEvent(const AliESDEvent *event);
 288   static void FillVarAODEvent(const AliAODEvent *event);
 289   static void FillVarMCEvent(const AliMCEvent *event);
 290   static void ResetArrayData(Int_t to);
 291   static void ResetArrayDataMC(Int_t to);
 292
 293   static Double_t GetPseudoProperTime(const AliDielectronPair *pair);
 294
 295   static AliPIDResponse *fgPIDResponse;        // PID response object
 296   static AliKFVertex     *fgKFVertex;          // KF vertex
 297   static AliAODVertex    *fgAODVertex;         // AOD vertex
 298
 299
 300   AliDielectronVarContainer(const AliDielectronVarContainer &c);
 301   AliDielectronVarContainer &operator=(const AliDielectronVarContainer &c);
 302
 303   ClassDef(AliDielectronVarContainer,1);
 304 };
 305
 306
 307 //Inline functions
 308 inline void AliDielectronVarContainer::Fill(const TObject* object)
 309 {
 310   //
 311   // Main function to fill all available variables according to the type of particle
 312   //
 313
 314   // Protect
 315   if (!object) return;
 316
 317   if      (object->IsA() == AliESDtrack::Class())       FillVarESDtrack(static_cast<const AliESDtrack*>(object));
 318   else if (object->IsA() == AliAODTrack::Class())       FillVarAODTrack(static_cast<const AliAODTrack*>(object));
 319   else if (object->IsA() == AliMCParticle::Class())     FillVarMCParticle(static_cast<const AliMCParticle*>(object));
 320   else if (object->IsA() == AliAODMCParticle::Class())  FillVarAODMCParticle(static_cast<const AliAODMCParticle*>(object));
 321   else if (object->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast<const AliDielectronPair*>(object));
 322   else if (object->IsA() == AliKFParticle::Class())     FillVarKFParticle(static_cast<const AliKFParticle*>(object));
 323   //else if (object->IsA() == TParticle::Class())         FillVarTParticle(static_cast<const TParticle*>(object));
 324
 325   // Main function to fill all available variables according to the type of event
 326   else if (object->IsA() == AliVEvent::Class())         FillVarVEvent(static_cast<const AliVEvent*>(object));
 327   else if (object->IsA() == AliESDEvent::Class())       FillVarESDEvent(static_cast<const AliESDEvent*>(object));
 328   else if (object->IsA() == AliAODEvent::Class())       FillVarAODEvent(static_cast<const AliAODEvent*>(object));
 329   else if (object->IsA() == AliMCEvent::Class())        FillVarMCEvent(static_cast<const AliMCEvent*>(object));
 330 //   else printf(Form("AliDielectronVarContainer::Fill: Type %s is not supported by AliDielectronVarContainer!", object->ClassName())); //TODO: implement without object needed
 331 }
 332
 333
 334
 335 inline void AliDielectronVarContainer::ResetArrayData(Int_t to)
 336 {
 337   // Protect
 338   if (to >= AliDielectronVarContainer::kNMaxValues) return;
 339   // Reset
 340   for (Int_t i=0; i<to; ++i) fgData[i] = 0.;
 341
 342   fgData[AliDielectronVarContainer::kTPCchi2Cl] = -1;
 343 }
 344
 345
 346 inline void AliDielectronVarContainer::ResetArrayDataMC(Int_t to)
 347 {
 348   // Protect
 349   if (to >= AliDielectronVarContainer::kNMaxValuesMC) return;
 350   // Reset
 351   //for (Int_t i=0; i<to; ++i) fgDataMC[i] = 0.;
 352
 353   //fgDataMC[AliDielectronVarContainer::kPdgCode]            = -1.;
 354   //fgDataMC[AliDielectronVarContainer::kPdgCodeMother]      = -1.;
 355   //fgDataMC[AliDielectronVarContainer::kPdgCodeGrandMother] = -1.;
 356   //fgDataMC[AliDielectronVarContainer::kNumberOfDaughters]  = -999.;
 357 }
 358
 359
 360 inline void AliDielectronVarContainer::FillVarVParticle(const AliVParticle *particle)
 361 {
 362   //
 363   // Fill track information available in AliVParticle into array
 364   //
 365
 366   // Protect
 367   if (!particle) return;
 368
 369   // Reset
 370   ResetArrayData(AliDielectronVarContainer::kPairMax);
 371
 372   // Set
 373   fgData[AliDielectronVarContainer::kPx]        = particle->Px();
 374   fgData[AliDielectronVarContainer::kPy]        = particle->Py();
 375   fgData[AliDielectronVarContainer::kPz]        = particle->Pz();
 376   fgData[AliDielectronVarContainer::kPt]        = particle->Pt();
 377   fgData[AliDielectronVarContainer::kP]         = particle->P();
 378   fgData[AliDielectronVarContainer::kXv]        = particle->Xv();
 379   fgData[AliDielectronVarContainer::kYv]        = particle->Yv();
 380   fgData[AliDielectronVarContainer::kZv]        = particle->Zv();
 381   fgData[AliDielectronVarContainer::kOneOverPt] = particle->OneOverPt();
 382   fgData[AliDielectronVarContainer::kPhi]       = particle->Phi();
 383   fgData[AliDielectronVarContainer::kTheta]     = particle->Theta();
 384   fgData[AliDielectronVarContainer::kEta]       = particle->Eta();
 385   fgData[AliDielectronVarContainer::kY]         = particle->Y();
 386   fgData[AliDielectronVarContainer::kE]         = particle->E();
 387   fgData[AliDielectronVarContainer::kM]         = particle->M();
 388   fgData[AliDielectronVarContainer::kCharge]    = particle->Charge();
 389   fgData[AliDielectronVarContainer::kPdgCode]   = particle->PdgCode();
 390 }
 391
 392
 393 inline void AliDielectronVarContainer::FillVarVParticleMC(const AliVParticle *particle)
 394 {
 395   //
 396   // Fill MC track information available in AliVParticle into array
 397   //
 398
 399   // Protect
 400   if (!particle) return;
 401
 402   // Get the MC interface if available
 403   AliDielectronMC *mc = AliDielectronMC::Instance();
 404   if (!mc->HasMC()) return;
 405
 406   // Reset
 407   ResetArrayDataMC(AliDielectronVarContainer::kPairMaxMC);
 408
 409   // If called for a reco track, get the MC track first
 410   if (particle->IsA() == AliESDtrack::Class()) particle = mc->GetMCTrack((AliESDtrack*)particle);
 411   if (particle->IsA() == AliAODTrack::Class()) particle = mc->GetMCTrack((AliAODTrack*)particle);
 412   if (!particle) return;
 413
 414   // Set the AliDielectronMC specific info
 415   if (particle->IsA() == AliMCParticle::Class()) {
 416     AliMCParticle* mcParticle = (AliMCParticle*)particle;
 417     if (mc->GetMCTrackMother(mcParticle)) {
 418       fgDataMC[AliDielectronVarContainer::kPdgCodeMother] = mc->GetMCTrackMother(mcParticle)->PdgCode();
 419       if (mc->GetMCTrackMother(mc->GetMCTrackMother(mcParticle)))
 420         fgDataMC[AliDielectronVarContainer::kPdgCodeGrandMother] = mc->GetMCTrackMother(mc->GetMCTrackMother(mcParticle))->PdgCode();;
 421     }
 422     fgDataMC[AliDielectronVarContainer::kNumberOfDaughters] = mc->NumberOfDaughters(mcParticle);
 423   } else if (particle->IsA() == AliAODMCParticle::Class()) {
 424     AliAODMCParticle* mcParticle = (AliAODMCParticle*)particle;
 425     if (mc->GetMCTrackMother(mcParticle)) {
 426       fgDataMC[AliDielectronVarContainer::kPdgCodeMother] = mc->GetMCTrackMother(mcParticle)->PdgCode();
 427       if (mc->GetMCTrackMother(mc->GetMCTrackMother(mcParticle)))
 428         fgDataMC[AliDielectronVarContainer::kPdgCodeGrandMother] = mc->GetMCTrackMother(mc->GetMCTrackMother(mcParticle))->PdgCode();;
 429     }
 430     fgDataMC[AliDielectronVarContainer::kNumberOfDaughters] = mc->NumberOfDaughters(mcParticle);
 431   }
 432
 433
 434   // Set the common info
 435   fgData[AliDielectronVarContainer::kIsJpsiPrimary]       = mc->IsJpsiPrimary(particle);
 436   fgDataMC[AliDielectronVarContainer::kPdgCode]           = particle->PdgCode();
 437   fgDataMC[AliDielectronVarContainer::kPxMC]             = particle->Px();
 438   fgDataMC[AliDielectronVarContainer::kPyMC]             = particle->Py();
 439   fgDataMC[AliDielectronVarContainer::kPzMC]             = particle->Pz();
 440   fgDataMC[AliDielectronVarContainer::kPtMC]             = particle->Pt();
 441   fgDataMC[AliDielectronVarContainer::kPMC]              = particle->P();
 442   fgDataMC[AliDielectronVarContainer::kXvMC]             = particle->Xv();
 443   fgDataMC[AliDielectronVarContainer::kYvMC]             = particle->Yv();
 444   fgDataMC[AliDielectronVarContainer::kZvMC]             = particle->Zv();
 445   fgDataMC[AliDielectronVarContainer::kOneOverPtMC]      = particle->OneOverPt();
 446   fgDataMC[AliDielectronVarContainer::kPhiMC]            = particle->Phi();
 447   fgDataMC[AliDielectronVarContainer::kThetaMC]          = particle->Theta();
 448   fgDataMC[AliDielectronVarContainer::kEtaMC]            = particle->Eta();
 449   fgDataMC[AliDielectronVarContainer::kYMC]              = particle->Y();
 450   fgDataMC[AliDielectronVarContainer::kEMC]              = particle->E();
 451   fgDataMC[AliDielectronVarContainer::kMMC]              = particle->M();
 452   fgDataMC[AliDielectronVarContainer::kChargeMC]         = particle->Charge();
 453 }
 454
 455
 456 inline void AliDielectronVarContainer::FillVarESDtrack(const AliESDtrack *particle)
 457 {
 458   //
 459   // Fill AliESDtrack interface specific information
 460   //
 461
 462   // Fill common AliVParticle interface information
 463   FillVarVParticle(particle);
 464   // Fill common MC information if available
 465   FillVarVParticleMC(particle);
 466
 467   Double_t tpcNcls=particle->GetTPCNcls();
 468   Double_t tpcSignalN=particle->GetTPCsignalN();
 469   fgData[AliDielectronVarContainer::kNclsITS]       = particle->GetNcls(0); // TODO: get rid of the plain numbers
 470   fgData[AliDielectronVarContainer::kNclsTPC]       = tpcNcls; // TODO: get rid of the plain numbers
 471   fgData[AliDielectronVarContainer::kNclsTPCiter1]  = particle->GetTPCNclsIter1(); // TODO: get rid of the plain numbers
 472   fgData[AliDielectronVarContainer::kNFclsTPC]      = particle->GetTPCNclsF();
 473   fgData[AliDielectronVarContainer::kNFclsTPCr]     = particle->GetTPCClusterInfo(2,1);
 474   fgData[AliDielectronVarContainer::kNFclsTPCrFrac] = particle->GetTPCClusterInfo(2);
 475   fgData[AliDielectronVarContainer::kTPCsignalN]    = tpcSignalN;
 476   fgData[AliDielectronVarContainer::kTPCsignalNfrac]= tpcNcls>0?tpcSignalN/tpcNcls:0;
 477   fgData[AliDielectronVarContainer::kNclsTRD]       = particle->GetNcls(2); // TODO: get rid of the plain numbers
 478   fgData[AliDielectronVarContainer::kTRDntracklets] = particle->GetTRDntracklets(); // TODO: GetTRDtracklets/GetTRDntracklets?
 479   fgData[AliDielectronVarContainer::kTRDpidQuality] = particle->GetTRDpidQuality();
 480   fgData[AliDielectronVarContainer::kTrackStatus]   = (Double_t)particle->GetStatus();
 481   if (tpcNcls>0) fgData[AliDielectronVarContainer::kTPCchi2Cl] = particle->GetTPCchi2() / tpcNcls;
 482
 483   //TRD pidProbs
 484   Double_t pidProbs[AliPID::kSPECIES];
 485   particle->GetTRDpid(pidProbs);
 486   fgData[AliDielectronVarContainer::kTRDprobEle]    = pidProbs[AliPID::kElectron];
 487   fgData[AliDielectronVarContainer::kTRDprobPio]    = pidProbs[AliPID::kPion];
 488
 489   fgData[AliDielectronVarContainer::kKinkIndex0]    = particle->GetKinkIndex(0);
 490
 491   Float_t impactParXY, impactParZ;
 492   particle->GetImpactParameters(impactParXY, impactParZ);
 493   fgData[AliDielectronVarContainer::kImpactParXY]   = impactParXY;
 494   fgData[AliDielectronVarContainer::kImpactParZ]    = impactParZ;
 495
 496   fgData[AliDielectronVarContainer::kITSsignal]       = particle->GetITSsignal();
 497
 498   Double_t itsdEdx[4];
 499   particle->GetITSdEdxSamples(itsdEdx);
 500
 501   fgData[AliDielectronVarContainer::kITSsignalSSD1]   = itsdEdx[0];
 502   fgData[AliDielectronVarContainer::kITSsignalSSD2]   = itsdEdx[1];
 503   fgData[AliDielectronVarContainer::kITSsignalSDD1]   = itsdEdx[2];
 504   fgData[AliDielectronVarContainer::kITSsignalSDD2]   = itsdEdx[3];
 505   fgData[AliDielectronVarContainer::kITSclusterMap]   = particle->GetITSClusterMap();
 506
 507   fgData[AliDielectronVarContainer::kTrackLength]     = particle->GetIntegratedLength();
 508
 509   //dEdx information
 510   Double_t mom = particle->GetP();
 511   const AliExternalTrackParam *in=particle->GetInnerParam();
 512   if (in) mom = in->GetP();
 513   fgData[AliDielectronVarContainer::kPIn]=mom;
 514   fgData[AliDielectronVarContainer::kTPCsignal]       = particle->GetTPCsignal();
 515   fgData[AliDielectronVarContainer::kTOFsignal]       = particle->GetTOFsignal();
 516
 517   Double_t l = particle->GetIntegratedLength();  // cm
 518   Double_t t = particle->GetTOFsignal();
 519   Double_t t0 = fgPIDResponse->GetTOFResponse().GetTimeZero(); // ps
 520
 521   if( (l < 360. || l > 800.) || (t <= 0.) || (t0 >999990.0) ) {
 522           fgData[AliDielectronVarContainer::kTOFbeta]=0.0;
 523   } else {
 524     t -= t0; // subtract the T0
 525     l *= 0.01;  // cm ->m
 526     t *= 1e-12; //ps -> s
 527
 528     Double_t v = l / t;
 529     Float_t beta = v / TMath::C();
 530     fgData[AliDielectronVarContainer::kTOFbeta] = beta;
 531   }
 532
 533   // nsigma to Electron band
 534   // TODO: for the moment we set the bethe bloch parameters manually
 535   //       this should be changed in future!
 536
 537   fgData[AliDielectronVarContainer::kTPCnSigmaEle]=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kElectron)-AliDielectronPID::GetCorrVal();
 538   fgData[AliDielectronVarContainer::kTPCnSigmaPio]=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kPion);
 539   fgData[AliDielectronVarContainer::kTPCnSigmaMuo]=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kMuon);
 540   fgData[AliDielectronVarContainer::kTPCnSigmaKao]=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kKaon);
 541   fgData[AliDielectronVarContainer::kTPCnSigmaPro]=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kProton);
 542
 543   fgData[AliDielectronVarContainer::kITSnSigmaEle]=fgPIDResponse->NumberOfSigmasITS(particle,AliPID::kElectron);
 544   fgData[AliDielectronVarContainer::kITSnSigmaPio]=fgPIDResponse->NumberOfSigmasITS(particle,AliPID::kPion);
 545   fgData[AliDielectronVarContainer::kITSnSigmaMuo]=fgPIDResponse->NumberOfSigmasITS(particle,AliPID::kMuon);
 546   fgData[AliDielectronVarContainer::kITSnSigmaKao]=fgPIDResponse->NumberOfSigmasITS(particle,AliPID::kKaon);
 547   fgData[AliDielectronVarContainer::kITSnSigmaPro]=fgPIDResponse->NumberOfSigmasITS(particle,AliPID::kProton);
 548
 549   fgData[AliDielectronVarContainer::kTOFnSigmaEle]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kElectron);
 550   fgData[AliDielectronVarContainer::kTOFnSigmaPio]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kPion);
 551   fgData[AliDielectronVarContainer::kTOFnSigmaMuo]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kMuon);
 552   fgData[AliDielectronVarContainer::kTOFnSigmaKao]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kKaon);
 553   fgData[AliDielectronVarContainer::kTOFnSigmaPro]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kProton);
 554 }
 555
 556 inline void AliDielectronVarContainer::FillVarAODTrack(const AliAODTrack *particle)
 557 {
 558   //
 559   // Fill track information available for histogramming into an array
 560   //
 561
 562   // Fill common AliVParticle interface information
 563   FillVarVParticle(particle);
 564   // Fill common MC information if available
 565   FillVarVParticleMC(particle);
 566
 567   Double_t tpcNcls=particle->GetTPCNcls();
 568   // Reset AliESDtrack interface specific information
 569   fgData[AliDielectronVarContainer::kNclsTPC]       = tpcNcls;
 570   fgData[AliDielectronVarContainer::kNclsTPCiter1]  = tpcNcls; // not really available in AOD
 571   fgData[AliDielectronVarContainer::kTrackStatus]   = (Double_t)particle->GetStatus();
 572
 573   //TODO: set TRD pidProbs correctly
 574
 575   // Fill AliAODTrack interface information
 576   //
 577   Double_t d0z0[2];
 578   GetDCA(particle, d0z0);
 579   fgData[AliDielectronVarContainer::kImpactParXY]   = d0z0[0];
 580   fgData[AliDielectronVarContainer::kImpactParZ]    = d0z0[1];
 581   fgData[AliDielectronVarContainer::kITSclusterMap] = particle->GetITSClusterMap();
 582
 583   AliAODPid *pid=particle->GetDetPid();
 584   if (pid){
 585     Double_t mom =pid->GetTPCmomentum();
 586     Double_t tpcSignalN=pid->GetTPCsignalN();
 587     fgData[AliDielectronVarContainer::kTPCsignalN] = tpcSignalN;
 588     fgData[AliDielectronVarContainer::kTPCsignalN] = tpcNcls>0?tpcSignalN/tpcNcls:0;
 589     Double_t tpcNsigmaEle=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kElectron);
 590     Double_t tpcNsigmaPio=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kPion);
 591     Double_t tpcNsigmaMuo=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kMuon);
 592     Double_t tpcNsigmaKao=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kKaon);
 593     Double_t tpcNsigmaPro=fgPIDResponse->NumberOfSigmasTPC(particle,AliPID::kProton);
 594
 595     fgData[AliDielectronVarContainer::kPIn]=mom;
 596     fgData[AliDielectronVarContainer::kTPCsignal]=pid->GetTPCsignal();
 597
 598     fgData[AliDielectronVarContainer::kTPCnSigmaEle]=tpcNsigmaEle;
 599     fgData[AliDielectronVarContainer::kTPCnSigmaPio]=tpcNsigmaPio;
 600     fgData[AliDielectronVarContainer::kTPCnSigmaMuo]=tpcNsigmaMuo;
 601     fgData[AliDielectronVarContainer::kTPCnSigmaKao]=tpcNsigmaKao;
 602     fgData[AliDielectronVarContainer::kTPCnSigmaPro]=tpcNsigmaPro;
 603   }
 604 }
 605
 606
 607 inline void AliDielectronVarContainer::FillVarMCParticle(const AliMCParticle *particle)
 608 {
 609   //
 610   // Fill track information available for histogramming into an array
 611   //
 612
 613   // Fill common AliVParticle interface information
 614   FillVarVParticle(particle);
 615   // Fill common MC information if available
 616   FillVarVParticleMC(particle);
 617
 618
 619   // Fill AliMCParticle interface specific information
 620
 621 }
 622
 623 inline void AliDielectronVarContainer::FillVarAODMCParticle(const AliAODMCParticle *particle)
 624 {
 625   //
 626   // Fill track information available for histogramming into an array
 627   //
 628
 629   // Fill common AliVParticle interface information
 630   FillVarVParticle(particle);
 631   // Fill common MC information if available
 632   FillVarVParticleMC(particle);
 633
 634
 635   // Fill AliAODMCParticle interface specific information
 636
 637 }
 638
 639 inline void AliDielectronVarContainer::FillVarDielectronPair(const AliDielectronPair *pair)
 640 {
 641   //
 642   // Fill pair information available for histogramming into an array
 643   //
 644
 645   // Fill common AliVParticle interface information
 646   FillVarVParticle(pair);
 647   // Reset MC array
 648   ResetArrayDataMC(AliDielectronVarContainer::kPairMaxMC);
 649
 650   // Fill AliDielectronPair specific information
 651   const AliKFParticle &kfPair = pair->GetKFParticle();
 652
 653   Double_t thetaHE=0;
 654   Double_t phiHE=0;
 655   Double_t thetaCS=0;
 656   Double_t phiCS=0;
 657
 658   pair->GetThetaPhiCM(thetaHE,phiHE,thetaCS,phiCS);
 659
 660   fgData[AliDielectronVarContainer::kChi2NDF]          = kfPair.GetChi2()/kfPair.GetNDF();
 661   fgData[AliDielectronVarContainer::kDecayLength]      = kfPair.GetDecayLength();
 662   fgData[AliDielectronVarContainer::kR]                = kfPair.GetR();
 663   fgData[AliDielectronVarContainer::kOpeningAngle]     = pair->OpeningAngle();
 664   fgData[AliDielectronVarContainer::kThetaHE]          = thetaHE;
 665   fgData[AliDielectronVarContainer::kPhiHE]            = phiHE;
 666   fgData[AliDielectronVarContainer::kThetaCS]          = thetaCS;
 667   fgData[AliDielectronVarContainer::kPhiCS]            = phiCS;
 668   fgData[AliDielectronVarContainer::kLegDist]          = pair->DistanceDaughters();
 669   fgData[AliDielectronVarContainer::kLegDistXY]        = pair->DistanceDaughtersXY();
 670   fgData[AliDielectronVarContainer::kDeltaEta]         = pair->DeltaEta();
 671   fgData[AliDielectronVarContainer::kDeltaPhi]         = pair->DeltaPhi();
 672   fgData[AliDielectronVarContainer::kMerr]             = kfPair.GetErrMass()>1e-30&&kfPair.GetMass()>1e-30?kfPair.GetErrMass()/kfPair.GetMass():1000000;
 673   fgData[AliDielectronVarContainer::kPairType]         = pair->GetType();
 674   fgData[AliDielectronVarContainer::kPseudoProperTime] = GetPseudoProperTime(pair);
 675
 676
 677   AliDielectronMC *mc=AliDielectronMC::Instance();
 678   if (mc->HasMC()){
 679     Bool_t samemother =  mc->HaveSameMother(pair);
 680     fgDataMC[AliDielectronVarContainer::kIsJpsiPrimary] = mc->IsJpsiPrimary(pair);
 681     fgDataMC[AliDielectronVarContainer::kHaveSameMother] = samemother ;
 682   }
 683
 684 }
 685
 686
 687 inline void AliDielectronVarContainer::FillVarKFParticle(const AliKFParticle *particle)
 688 {
 689   //
 690   // Fill track information available in AliKFParticle into an array
 691   //
 692
 693   // Reset data array
 694   ResetArrayData(AliDielectronVarContainer::kPairMax);
 695   // Reset MC array
 696   ResetArrayDataMC(AliDielectronVarContainer::kPairMaxMC);
 697
 698
 699   fgData[AliDielectronVarContainer::kPx]        = particle->GetPx();
 700   fgData[AliDielectronVarContainer::kPy]        = particle->GetPy();
 701   fgData[AliDielectronVarContainer::kPz]        = particle->GetPz();
 702   fgData[AliDielectronVarContainer::kPt]        = particle->GetPt();
 703   fgData[AliDielectronVarContainer::kP]         = particle->GetP();
 704   fgData[AliDielectronVarContainer::kXv]        = particle->GetX();
 705   fgData[AliDielectronVarContainer::kYv]        = particle->GetY();
 706   fgData[AliDielectronVarContainer::kZv]        = particle->GetZ();
 707   fgData[AliDielectronVarContainer::kPhi]       = particle->GetPhi();
 708   fgData[AliDielectronVarContainer::kEta]       = particle->GetEta();
 709   fgData[AliDielectronVarContainer::kY]         = ((particle->GetE()*particle->GetE()-particle->GetPx()*particle->GetPx()-particle->GetPy()*particle->GetPy()-particle->GetPz()*particle->GetPz())>0.) ? TLorentzVector(particle->GetPx(),particle->GetPy(),particle->GetPz(),particle->GetE()).Rapidity() : -1111.;
 710   fgData[AliDielectronVarContainer::kE]         = particle->GetE();
 711   fgData[AliDielectronVarContainer::kM]         = particle->GetMass();
 712   fgData[AliDielectronVarContainer::kCharge]    = particle->GetQ();
 713 }
 714
 715
 716 inline void AliDielectronVarContainer::FillVarVEvent(const AliVEvent *event)
 717 {
 718   //
 719   // Fill event information available for histogramming into an array
 720   //
 721
 722   // Reset data array
 723   ResetArrayData(AliDielectronVarContainer::kNMaxValues);
 724   // Reset MC array
 725   ResetArrayDataMC(AliDielectronVarContainer::kNMaxValuesMC);
 726
 727   // set the KF vertex
 728   if (fgKFVertex) delete fgKFVertex;
 729   fgKFVertex = 0x0;
 730   if (!event->GetPrimaryVertex()) return;
 731   fgKFVertex = new AliKFVertex(*event->GetPrimaryVertex());
 732
 733
 734   fgData[AliDielectronVarContainer::kXvPrim]       = event->GetPrimaryVertex()->GetX();
 735   fgData[AliDielectronVarContainer::kYvPrim]       = event->GetPrimaryVertex()->GetY();
 736   fgData[AliDielectronVarContainer::kZvPrim]       = event->GetPrimaryVertex()->GetZ();
 737   fgData[AliDielectronVarContainer::kNContrib]     = event->GetPrimaryVertex()->GetNContributors();
 738   //fgData[AliDielectronVarContainer::kChi2NDF]      = event->GetPrimaryVertex()->GetChi2perNDF(); // This is the pair value!
 739   fgData[AliDielectronVarContainer::kNTrk]         = event->GetNumberOfTracks();
 740   fgData[AliDielectronVarContainer::kBzkG]         = event->GetMagneticField();
 741   fgData[AliDielectronVarContainer::kNacc]         = AliDielectronHelper::GetNacc(event);
 742   fgData[AliDielectronVarContainer::kNaccTrcklts]  = AliDielectronHelper::GetNaccTrcklts(event,1.6);
 743   fgData[AliDielectronVarContainer::kNaccTrcklts05]   = AliDielectronHelper::GetNaccTrcklts(event, 0.5);
 744   fgData[AliDielectronVarContainer::kNaccTrcklts10]   = AliDielectronHelper::GetNaccTrcklts(event, 1.0);
 745   fgData[AliDielectronVarContainer::kNaccTrckltsCorr] = AliDielectronHelper::GetNaccTrckltsCorrected(event, values[AliDielectronVarContainer::kNaccTrcklts], values[AliDielectronVarContainer::kZvPrim]);
 746 }
 747
 748
 749 inline void AliDielectronVarContainer::FillVarESDEvent(const AliESDEvent *event)
 750 {
 751   //
 752   // Fill event information available for histogramming into an array
 753   //
 754
 755   // Fill common AliVEvent interface information
 756   FillVarVEvent(event);
 757
 758   Double_t centralityF=-1;
 759   AliCentrality *esdCentrality = const_cast<AliESDEvent*>(event)->GetCentrality();
 760   if (esdCentrality) centralityF = esdCentrality->GetCentralityPercentile("V0M");
 761
 762   // Fill AliESDEvent interface specific information
 763   const AliESDVertex *esdVtx = event->GetPrimaryVertex();
 764   fgData[AliDielectronVarContainer::kXRes]       = esdVtx->GetXRes();
 765   fgData[AliDielectronVarContainer::kYRes]       = esdVtx->GetYRes();
 766   fgData[AliDielectronVarContainer::kZRes]       = esdVtx->GetZRes();
 767   fgData[AliDielectronVarContainer::kCentrality] = centralityF;
 768
 769   // Event multiplicity estimators
 770   Int_t nTrSPD=0; Int_t nTrITSTPC=0; Int_t nTrITSSA=0;
 771   event->EstimateMultiplicity(nTrSPD, nTrITSTPC, nTrITSSA, 0.5);
 772   fgData[AliDielectronVarContainer::kNaccTrckltsEsd05] = nTrSPD;
 773   fgData[AliDielectronVarContainer::kNaccItsTpcEsd05] = nTrITSTPC;
 774   fgData[AliDielectronVarContainer::kNaccItsPureEsd05] = nTrITSSA;
 775   event->EstimateMultiplicity(nTrSPD, nTrITSTPC, nTrITSSA, 1.0);
 776   fgData[AliDielectronVarContainer::kNaccTrckltsEsd10] = nTrSPD;
 777   fgData[AliDielectronVarContainer::kNaccItsTpcEsd10] = nTrITSTPC;
 778   fgData[AliDielectronVarContainer::kNaccItsPureEsd10] = nTrITSSA;
 779   event->EstimateMultiplicity(nTrSPD, nTrITSTPC, nTrITSSA, 1.6);
 780   fgData[AliDielectronVarContainer::kNaccTrckltsEsd16] = nTrSPD;
 781   fgData[AliDielectronVarContainer::kNaccItsTpcEsd16] = nTrITSTPC;
 782   fgData[AliDielectronVarContainer::kNaccItsPureEsd16] = nTrITSSA;
 783
 784   // ESD VZERO information
 785   AliESDVZERO* vzeroData = event->GetVZEROData();
 786   fgData[AliDielectronVarContainer::kMultV0A] = 0.0;
 787   fgData[AliDielectronVarContainer::kMultV0C] = 0.0;
 788   fgData[AliDielectronVarContainer::kAdcV0A]  = 0.0;
 789   fgData[AliDielectronVarContainer::kAdcV0C]  = 0.0;
 790   for(Int_t i=0; i<32; ++i) {
 791     fgData[AliDielectronVarContainer::kMultV0A] += vzeroData->GetMultiplicityV0A(i);
 792     fgData[AliDielectronVarContainer::kMultV0C] += vzeroData->GetMultiplicityV0C(i);
 793     fgData[AliDielectronVarContainer::kAdcV0A] += vzeroData->GetAdcV0A(i);
 794     fgData[AliDielectronVarContainer::kAdcV0C] += vzeroData->GetAdcV0C(i);
 795   }
 796   fgData[AliDielectronVarContainer::kMultV0] = fgData[AliDielectronVarContainer::kMultV0A] + fgData[AliDielectronVarContainer::kMultV0C];
 797   fgData[AliDielectronVarContainer::kAdcV0] = fgData[AliDielectronVarContainer::kAdcV0A] + fgData[AliDielectronVarContainer::kAdcV0C];
 798
 799 }
 800
 801
 802 inline void AliDielectronVarContainer::FillVarAODEvent(const AliAODEvent *event)
 803 {
 804   //
 805   // Fill event information available for histogramming into an array
 806   //
 807
 808   // Fill common AliVEvent interface information
 809   FillVarVEvent(event);
 810
 811   // Fill AliAODEvent interface specific information
 812   // set the AOD vertex
 813   if (fgAODVertex) delete fgAODVertex;
 814   fgAODVertex = 0x0;
 815   if (!event->GetPrimaryVertex()) return;
 816   fgAODVertex = new AliAODVertex(*event->GetPrimaryVertex());
 817
 818   // AOD VZERO information
 819   AliAODVZERO* vzeroData = event->GetVZEROData();
 820   fgData[AliDielectronVarContainer::kMultV0A] = 0.0;
 821   fgData[AliDielectronVarContainer::kMultV0C] = 0.0;
 822   for(Int_t i=0; i<32; ++i) {
 823     fgData[AliDielectronVarContainer::kMultV0A] += vzeroData->GetMultiplicityV0A(i);
 824     fgData[AliDielectronVarContainer::kMultV0C] += vzeroData->GetMultiplicityV0C(i);
 825   }
 826   fgData[AliDielectronVarContainer::kMultV0] = fgData[AliDielectronVarContainer::kMultV0A] + fgData[AliDielectronVarContainer::kMultV0C];
 827   // adc amplitides not available in aods
 828   fgData[AliDielectronVarContainer::kAdcV0] = 0.0;
 829   fgData[AliDielectronVarContainer::kAdcV0A]  = 0.0;
 830   fgData[AliDielectronVarContainer::kAdcV0C]  = 0.0;
 831 }
 832
 833
 834 inline void AliDielectronVarContainer::FillVarMCEvent(const AliMCEvent *event)
 835 {
 836   //
 837   // Fill event information available for histogramming into an array
 838   //
 839
 840   // Fill common AliVEvent interface information
 841   FillVarVEvent(event);
 842
 843   // Fill AliMCEvent interface specific information
 844   fgDataMC[AliDielectronVarContainer::kNch] = AliDielectronHelper::GetNch(event, 1.6);
 845   fgDataMC[AliDielectronVarContainer::kNch05] = AliDielectronHelper::GetNch(event, 0.5);
 846   fgDataMC[AliDielectronVarContainer::kNch10] = AliDielectronHelper::GetNch(event, 1.0);
 847 }
 848
 849
 850 inline Double_t AliDielectronVarContainer::GetPseudoProperTime(const AliDielectronPair *pair)
 851 {
 852   //
 853   // Calculate the pseudo proper time
 854   //
 855
 856   if(!pair) return 0.;
 857
 858   Double_t pt  = pair->Pt();
 859   Double_t dx  = pair->Xv() - fgData[AliDielectronVarContainer::kXvPrim];
 860   Double_t dy  = pair->Yv() - fgData[AliDielectronVarContainer::kYvPrim];
 861   Double_t lxy = ((dx * pair->Px()) + (dy * pair->Py()))/pt;
 862   Double_t ppt = lxy * (TDatabasePDG::Instance()->GetParticle(443)->Mass())/pt;
 863
 864   return ppt;
 865 }
 866
 867
 868 inline void AliDielectronVarContainer::SetEvent(AliVEvent * const event)
 869 {
 870   //
 871   // Set the event
 872   //
 873
 874   FillVarVEvent(event);
 875 }
 876
 877
 878 inline void AliDielectronVarContainer::InitESDpid(Int_t type)
 879 {
 880   //
 881   // initialize PID parameters
 882   // type=0 is simulation
 883   // type=1 is data
 884
 885   if (!fgPIDResponse) fgPIDResponse=new AliESDpid((Bool_t)(type==0));
 886   Double_t alephParameters[5];
 887   // simulation
 888   alephParameters[0] = 2.15898e+00/50.;
 889   alephParameters[1] = 1.75295e+01;
 890   alephParameters[2] = 3.40030e-09;
 891   alephParameters[3] = 1.96178e+00;
 892   alephParameters[4] = 3.91720e+00;
 893   fgPIDResponse->GetTOFResponse().SetTimeResolution(80.);
 894
 895   // data
 896   if (type==1){
 897     alephParameters[0] = 0.0283086/0.97;
 898     alephParameters[1] = 2.63394e+01;
 899     alephParameters[2] = 5.04114e-11;
 900     alephParameters[3] = 2.12543e+00;
 901     alephParameters[4] = 4.88663e+00;
 902     fgPIDResponse->GetTOFResponse().SetTimeResolution(130.);
 903     fgPIDResponse->GetTPCResponse().SetMip(50.);
 904   }
 905
 906   fgPIDResponse->GetTPCResponse().SetBetheBlochParameters(
 907     alephParameters[0],alephParameters[1],alephParameters[2],
 908     alephParameters[3],alephParameters[4]);
 909
 910   fgPIDResponse->GetTPCResponse().SetSigma(3.79301e-03, 2.21280e+04);
 911 }
 912
 913 inline void AliDielectronVarContainer::InitAODpidUtil(Int_t type)
 914 {
 915   if (!fgPIDResponse) fgPIDResponse=new AliAODpidUtil;
 916   Double_t alephParameters[5];
 917   // simulation
 918   alephParameters[0] = 2.15898e+00/50.;
 919   alephParameters[1] = 1.75295e+01;
 920   alephParameters[2] = 3.40030e-09;
 921   alephParameters[3] = 1.96178e+00;
 922   alephParameters[4] = 3.91720e+00;
 923   fgPIDResponse->GetTOFResponse().SetTimeResolution(80.);
 924
 925   // data
 926   if (type==1){
 927     alephParameters[0] = 0.0283086/0.97;
 928     alephParameters[1] = 2.63394e+01;
 929     alephParameters[2] = 5.04114e-11;
 930     alephParameters[3] = 2.12543e+00;
 931     alephParameters[4] = 4.88663e+00;
 932     fgPIDResponse->GetTOFResponse().SetTimeResolution(130.);
 933     fgPIDResponse->GetTPCResponse().SetMip(50.);
 934   }
 935
 936   fgPIDResponse->GetTPCResponse().SetBetheBlochParameters(
 937     alephParameters[0],alephParameters[1],alephParameters[2],
 938     alephParameters[3],alephParameters[4]);
 939
 940   fgPIDResponse->GetTPCResponse().SetSigma(3.79301e-03, 2.21280e+04);
 941 }
 942
 943
 944 inline Bool_t AliDielectronVarContainer::GetDCA(const AliAODTrack *track, Double_t d0z0[2])
 945 {
 946   if(track->TestBit(AliAODTrack::kIsDCA)){
 947     d0z0[0]=track->DCA();
 948     d0z0[1]=track->ZAtDCA();
 949     return kTRUE;
 950   }
 951
 952   Double_t covd0z0[3];
 953   AliAODTrack copy(*track);
 954   AliAODVertex *vtx =(AliAODVertex*)fgAODVertex;
 955   Bool_t ok = copy.PropagateToDCA(vtx,fgData[AliDielectronVarContainer::kBzkG],kVeryBig,d0z0,covd0z0);
 956   if(!ok){
 957     d0z0[0]=-999.;
 958     d0z0[1]=-999.;
 959   }
 960   return ok;
 961 }
 962
 963 /*
 964 inline void AliDielectronVarContainer::FillVarTParticle(const TParticle *particle)
 965 {
 966   //
 967   // Fill TParticle interface information
 968   //
 969
 970   fgData[AliDielectronVarContainer::kPx]        = particle->Px();
 971   fgData[AliDielectronVarContainer::kPy]        = particle->Py();
 972   fgData[AliDielectronVarContainer::kPz]        = particle->Pz();
 973   fgData[AliDielectronVarContainer::kPt]        = particle->Pt();
 974   fgData[AliDielectronVarContainer::kP]         = particle->P();
 975   fgData[AliDielectronVarContainer::kXv]        = particle->Vx();
 976   fgData[AliDielectronVarContainer::kYv]        = particle->Vy();
 977   fgData[AliDielectronVarContainer::kZv]        = particle->Vz();
 978   fgData[AliDielectronVarContainer::kOneOverPt] = 1./particle->Pt();
 979   fgData[AliDielectronVarContainer::kPhi]       = particle->Phi();
 980   fgData[AliDielectronVarContainer::kTheta]     = particle->Theta();
 981   fgData[AliDielectronVarContainer::kEta]       = particle->Eta();
 982   fgData[AliDielectronVarContainer::kY]         = particle->Y();
 983   fgData[AliDielectronVarContainer::kE]         = particle->Energy();
 984   fgData[AliDielectronVarContainer::kM]         = particle->GetMass();
 985   fgData[AliDielectronVarContainer::kCharge]    = particle->GetPDG()->Charge()/3;
 986 }
 987 */
 988
 989
 990
 991
 992 #endif
 993