add V0 particle identification (Alex Markus)
authorabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 3 Oct 2012 11:23:11 +0000 (11:23 +0000)
committerabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 3 Oct 2012 11:23:11 +0000 (11:23 +0000)
add ESD summary maker as default processor
extend trending for MC data
fix warnings
various corrections/addings

16 files changed:
PWGPP/TRD/AliTRDcalibration.cxx
PWGPP/TRD/AliTRDcheckPID.cxx
PWGPP/TRD/AliTRDefficiency.cxx
PWGPP/TRD/AliTRDefficiency.h
PWGPP/TRD/AliTRDinfoGen.cxx
PWGPP/TRD/AliTRDinfoGen.h
PWGPP/TRD/AliTRDrecoTask.cxx
PWGPP/TRD/AliTRDrecoTask.h
PWGPP/TRD/AliTRDresolution.cxx
PWGPP/TRD/info/AliTRDtrackInfo.cxx
PWGPP/TRD/info/AliTRDtrackInfo.h
PWGPP/TRD/info/AliTRDtrendingManager.cxx
PWGPP/TRD/info/AliTRDv0Info.cxx
PWGPP/TRD/info/AliTRDv0Info.h
PWGPP/TRD/macros/makeResults.C
PWGPP/TRD/macros/makeTrendingDB.C

index fd2d22a..38ab9d1 100644 (file)
@@ -405,11 +405,11 @@ void AliTRDcalibration::UserExec(Option_t *)
        Float_t normalisation = 6.67;
        Int_t detector = 0;
        Int_t sector = 0;
-       Int_t crossrow = 0;
-       // Check no shared clusters
-       for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
-         if((fcl = tracklet->GetClusters(icc)))  crossrow = 1;
-       }
+  /*Int_t crossrow = 0;
+  // Check no shared clusters
+  for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
+    if((fcl = tracklet->GetClusters(icc)))  crossrow = 1;
+  }*/
        // Loop on clusters
        for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
          if(!(fcl = tracklet->GetClusters(ic))) continue;
@@ -808,7 +808,7 @@ Bool_t AliTRDcalibration::PostProcess()
     PostProcess();
   }
 
-  Bool_t storage[3] = {kFALSE,kFALSE,kFALSE};
+//  Bool_t storage[3] = {kFALSE,kFALSE,kFALSE};
 
   // Objects for fitting
   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
@@ -868,7 +868,7 @@ Bool_t AliTRDcalibration::PostProcess()
          // store
          fArrayCalib->AddAt(objgaindet,0);
          fArrayCalib->AddAt(objgainpad,1);
-         storage[0] = kTRUE;
+         //storage[0] = kTRUE;
          // Make graph
          TGraph *graph = 0x0;
          if(FillGraphIndex(&object,graph)){ 
index e261abe..10e6912 100644 (file)
@@ -835,17 +835,17 @@ TH1 *AliTRDcheckPID::PlotMom(const AliTRDtrackV1 *track)
   }
 
 
-  Int_t pdg = 0;
+//  Int_t pdg = 0;
   Float_t momentum = 0.;
   if(fkMC){
     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
-    pdg = fkMC->GetPDG();
+    //pdg = fkMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
     AliTRDtrackV1 cTrack(*fkTrack);
     cTrack.SetReconstructor(AliTRDinfoGen::Reconstructor());
     momentum = cTrack.GetMomentum(0);
-    pdg = CalcPDG(&cTrack);
+    //pdg = CalcPDG(&cTrack);
   }
   if(IsInRange(momentum)) hMom -> Fill(momentum);
   return hMom;
@@ -874,12 +874,12 @@ TH1 *AliTRDcheckPID::PlotMomBin(const AliTRDtrackV1 *track)
   }
 
 
-  Int_t pdg = 0;
+  //Int_t pdg = 0;
   Float_t momentum = 0.;
 
   if(fkMC){
     if(fkMC->GetTrackRef()) momentum = fkMC->GetTrackRef()->P();
-    pdg = fkMC->GetPDG();
+    //pdg = fkMC->GetPDG();
   } else {
     //AliWarning("No MC info available!");
     AliTRDtrackV1 cTrack(*fkTrack);
index 59f50a6..1d512ac 100644 (file)
@@ -568,7 +568,7 @@ Bool_t AliTRDefficiency::MakeProjectionBasicEff()
   Int_t jh(0);
   for(; ih--; ){
     if(!hp[ih].H()) continue;
-    for(Int_t ipt(0); ipt<=fNpt; ipt++) fProj->AddAt(Projection2D(hp[ih].H(), ipt), jh++);
+    for(Int_t ipt(0); ipt<=fNpt; ipt++) fProj->AddAt(hp[ih].Projection2Dbin(ipt), jh++);
   }
 
 /*  AliTRDrecoProjection prLab;  TH2 *hLab[3] = {0}; TH1 *hpLab[3] = {0};
@@ -592,7 +592,7 @@ Bool_t AliTRDefficiency::MakeProjectionBasicEff()
         (*pr0)+=(*pr1);
       }
       pr0->H()->SetNameTitle(Form("HEff%d", istat), Form("Efficiency :: Stat[#bf{%s}]", stat[istat]));
-      for(Int_t ipt(0); ipt<=fNpt; ipt++) fProj->AddAt(Projection2D(pr0->H(), ipt), jh++);
+      for(Int_t ipt(0); ipt<=fNpt; ipt++) fProj->AddAt(pr0->Projection2Dbin(ipt), jh++);
 
       if(istat>1 && (pr1 = (AliTRDrecoProjection*)php.FindObject("HEff01"))) (*pr1)+=(*pr0);
       if(istat>2 && (pr1 = (AliTRDrecoProjection*)php.FindObject("HEff02"))) (*pr1)+=(*pr0);
@@ -605,7 +605,7 @@ Bool_t AliTRDefficiency::MakeProjectionBasicEff()
   for(Int_t istat(0); istat<3; istat++){
     if(!(pr0 = (AliTRDrecoProjection*)php.FindObject(Form("HEff%d%d", 0, istat+1)))) continue;
     pr0->H()->SetNameTitle(Form("HEff%c", suffix[istat]), Form("Efficiency :: %s Tracks", sname[istat]));
-    for(Int_t ipt(-1); ipt<=fNpt; ipt++) fProj->AddAt(Projection2D(pr0->H(), ipt), jh++);
+    for(Int_t ipt(-1); ipt<=fNpt; ipt++) fProj->AddAt(pr0->Projection2Dbin(ipt), jh++);
   }
 
   // Efficiency
@@ -773,27 +773,3 @@ void AliTRDefficiency::MakeSummary()
   hs->GetYaxis()->CenterTitle();
   cOut->SaveAs(Form("%s.gif", cOut->GetName()));
 }
-
-
-//____________________________________________________________________
-TH2* AliTRDefficiency::Projection2D(TH3 *h3, Int_t ipt)
-{
-  TAxis *ax(h3->GetXaxis()), *ay(h3->GetYaxis());
-  TH2F *h2(NULL);
-  if(ipt<0){
-    h2 =(TH2F*)h3->Project3D("yx");
-    h2->SetNameTitle(Form("%s%d_2D", h3->GetName(), ipt), h3->GetTitle());
-  } else {
-    h2 = new TH2F(Form("%s%d_2D", h3->GetName(), ipt),
-                  Form("%s | #it{%4.2f<=p_{t}[GeV/c]<%4.2f};%s;%s;Entries", h3->GetTitle(),
-                  ipt?fgPt[ipt-1]:0., ipt==fNpt?9.99:fgPt[ipt], ax->GetTitle(), ay->GetTitle()),
-                  ax->GetNbins(), ax->GetXmin(), ax->GetXmax(),
-                  ay->GetNbins(), ay->GetXmin(), ay->GetXmax());
-    for(Int_t ix(1); ix<=ax->GetNbins(); ix++){
-      for(Int_t iy(1); iy<=ay->GetNbins(); iy++){
-        h2->SetBinContent(ix, iy, h3->GetBinContent(ix, iy, ipt));
-      }
-    }
-  }
-  return h2;
-}
index b8e84dd..cdeedc8 100644 (file)
@@ -49,7 +49,6 @@ protected:
 private:
   AliTRDefficiency(const AliTRDefficiency&);
   AliTRDefficiency& operator=(const AliTRDefficiency&);
-  TH2*         Projection2D(TH3 *h3, Int_t ipt);
 
   TClonesArray     *fMissed;          // Missed ?
   TObjArray        *fProj;            //! result holder - sigma values
index e4d8402..b778ad6 100644 (file)
@@ -66,6 +66,7 @@
 #include "AliESDtrack.h"\r
 #include "AliESDv0.h"\r
 #include "AliESDtrackCuts.h"\r
+#include "AliESDv0KineCuts.h"\r
 #include "AliMCParticle.h"\r
 #include "AliMultiplicity.h"\r
 #include "AliCentrality.h"\r
@@ -118,6 +119,7 @@ AliTRDinfoGen::AliTRDinfoGen()
   ,fMCev(NULL)\r
   ,fEventCut(NULL)\r
   ,fTrackCut(NULL)\r
+  ,fV0Identifier(NULL)\r
   ,fV0Cut(NULL)\r
   ,fOCDB("local://$ALICE_ROOT/OCDB")\r
   ,fTrackInfo(NULL)\r
@@ -145,6 +147,7 @@ AliTRDinfoGen::AliTRDinfoGen(char* name)
   ,fMCev(NULL)\r
   ,fEventCut(NULL)\r
   ,fTrackCut(NULL)\r
+  ,fV0Identifier(NULL)\r
   ,fV0Cut(NULL)\r
   ,fOCDB("local://$ALICE_ROOT/OCDB")\r
   ,fTrackInfo(NULL)\r
@@ -180,6 +183,7 @@ AliTRDinfoGen::~AliTRDinfoGen()
   if(fgReconstructor) delete fgReconstructor;\r
   if(fDebugStream) delete fDebugStream;\r
   if(fV0Cut) delete fV0Cut;\r
+  if(fV0Identifier) delete fV0Identifier;\r
   if(fTrackCut) delete fTrackCut;\r
   if(fEventCut) delete fEventCut;\r
   if(fTrackInfo) delete fTrackInfo; fTrackInfo = NULL;\r
@@ -450,6 +454,10 @@ void AliTRDinfoGen::UserExec(Option_t *){
   }\r
   UShort_t evBC(fESDev->GetBunchCrossNumber());\r
 \r
+  // electron identifier from conversions\r
+  if(!fV0Identifier) fV0Identifier = new AliESDv0KineCuts();\r
+  fV0Identifier->SetEvent(fESDev);\r
+\r
   Bool_t *trackMap(NULL);\r
   AliStack * mStack(NULL);\r
   Int_t nTracksMC = HasMCdata() ? fMCev->GetNumberOfTracks() : 0, nTracksESD = fESDev->GetNumberOfTracks();\r
@@ -465,7 +473,7 @@ void AliTRDinfoGen::UserExec(Option_t *){
   \r
   Double32_t dedx[100]; Int_t nSlices(0);\r
   Int_t nTRDout(0), nTRDin(0), nTPC(0), nITS(0)\r
-       ,nclsTrklt\r
+//        ,nclsTrklt\r
        ,nBarrel(0), nSA(0), nKink(0)\r
        ,nBarrelFriend(0), nSAFriend(0)\r
        ,nBarrelMC(0), nSAMC(0), nKinkMC(0);\r
@@ -482,13 +490,24 @@ void AliTRDinfoGen::UserExec(Option_t *){
   AliESDv0 *v0(NULL);\r
   Int_t v0pid[AliPID::kSPECIES];\r
   for(Int_t iv0(0); iv0<fESDev->GetNumberOfV0s(); iv0++){\r
-    if(!(v0 = fESDev->GetV0(iv0))) continue;\r
+    if(!(v0 = fESDev->GetV0(iv0)) && !v0->GetOnFlyStatus()) continue; // Take only V0s from the On-the-fly v0 finder\r
     // register v0\r
     if(fV0Cut) new(fV0Info) AliTRDv0Info(*fV0Cut);\r
     else new(fV0Info) AliTRDv0Info();\r
     fV0Info->SetMagField(bField);\r
     fV0Info->SetV0tracks(fESDev->GetTrack(v0->GetPindex()), fESDev->GetTrack(v0->GetNindex()));\r
     fV0Info->SetV0Info(v0);\r
+    // tag conversion electrons\r
+    Int_t pdgV0, pdgP, pdgN;\r
+    if(fV0Identifier->ProcessV0(v0, pdgV0, pdgP, pdgN)) {\r
+      switch(pdgV0){\r
+      case kGamma: fV0Info->SetDecay(AliTRDv0Info::kGamma); break;\r
+      case kK0Short: fV0Info->SetDecay(AliTRDv0Info::kK0s); break;\r
+      case kLambda0: fV0Info->SetDecay(AliTRDv0Info::kLambda); break;\r
+      case kLambda0Bar: fV0Info->SetDecay(AliTRDv0Info::kAntiLambda); break;\r
+      default: AliDebug(1, Form("V0[%+4d] -> +[%+4d] -[%+4d]. Decay not mapped.", pdgV0, pdgP, pdgN));\r
+      }\r
+    }\r
     fV0List->Add(new AliTRDv0Info(*fV0Info));//  kFOUND=kFALSE;\r
   }\r
 \r
@@ -588,20 +607,24 @@ void AliTRDinfoGen::UserExec(Option_t *){
     Float_t tofTime = esdTrack->GetTOFsignal() - fESDev->GetT0TOF(0);\r
     fTrackInfo->SetTOFbeta(tofTime>0.?((esdTrack->GetIntegratedLength()/(tofTime*TMath::C()))*10e9):-999.);\r
     fTrackInfo->SetTOFbc(esdTrack->GetTOFBunchCrossing()==AliVTrack::kTOFBCNA?0:esdTrack->GetTOFBunchCrossing());\r
-    nclsTrklt = 0;\r
+//    nclsTrklt = 0;\r
   \r
     // set V0pid info\r
+    //printf("%4d Looking for V0s...\n" , fTrackInfo->GetTrackId());\r
     for(Int_t iv(0); iv<fV0List->GetEntriesFast(); iv++){\r
       if(!(v0info = (AliTRDv0Info*)fV0List->At(iv))) continue;\r
       if(!v0info->GetV0Daughter(1) && !v0info->GetV0Daughter(-1)) continue;\r
       if(!v0info->HasTrack(fTrackInfo)) continue;\r
+      //v0info->Print();\r
       memset(v0pid, 0, AliPID::kSPECIES*sizeof(Int_t));\r
       fTrackInfo->SetV0();\r
-      for(Int_t is=AliPID::kSPECIES; is--;){v0pid[is] = v0info->GetPID(is, fTrackInfo);}\r
-      fTrackInfo->SetV0pid(v0pid);\r
-      fTrackInfo->SetV0();\r
-      //const AliTRDtrackInfo::AliESDinfo *ei = fTrackInfo->GetESDinfo();\r
-      break;\r
+      for(Int_t is=AliPID::kSPECIES; is--;) v0pid[is] = v0info->GetPID(is, fTrackInfo); fTrackInfo->SetV0pid(v0pid);\r
+      if(v0info->IsDecay(AliTRDv0Info::kGamma)) fTrackInfo->SetElectron();\r
+      else if(v0info->IsDecay(AliTRDv0Info::kK0s)) fTrackInfo->SetPion();\r
+      else if(v0info->IsDecay(AliTRDv0Info::kLambda)) esdTrack->Charge()>0?fTrackInfo->SetProton():fTrackInfo->SetPion();\r
+      else if(v0info->IsDecay(AliTRDv0Info::kAntiLambda)) esdTrack->Charge()<0?fTrackInfo->SetProton():fTrackInfo->SetPion();\r
+      \r
+      //TODO one track can be attached to more than one v0. Ideally one would need a list of v0 attached to the track info\r
     }\r
 \r
     // read track REC info\r
index ae77952..d6e1bad 100644 (file)
@@ -23,6 +23,7 @@ class AliTRDeventInfo;
 class AliTRDv0Info;\r
 class AliTRDeventCuts;\r
 class AliESDtrackCuts;\r
+class AliESDv0KineCuts;\r
 class TObjArray;\r
 class TString;\r
 class TTreeSRedirector;\r
@@ -127,6 +128,7 @@ private:
   // event/track cuts OO - to be used\r
   AliTRDeventCuts  *fEventCut;       // event cut\r
   AliESDtrackCuts  *fTrackCut;       // track cut\r
+  AliESDv0KineCuts *fV0Identifier;   // V0 identifier\r
   AliTRDv0Info     *fV0Cut;          // v0 cut\r
   TString           fOCDB;           // OCDB location\r
   AliTRDtrackInfo  *fTrackInfo;      //! Track info\r
@@ -141,6 +143,6 @@ private:
   TObjArray        *fRecos;          //! array of reco params\r
   TTreeSRedirector *fDebugStream;    //! debug stream\r
 \r
-  ClassDef(AliTRDinfoGen, 7)         // entry to TRD analysis train\r
+  ClassDef(AliTRDinfoGen, 8)         // entry to TRD analysis train\r
 };\r
 #endif\r
index b948a56..2dcca06 100644 (file)
@@ -63,7 +63,7 @@ AliTRDrecoTask::AliTRDrecoTask()
   ,fkMC(NULL)\r
   ,fkESD(NULL)\r
   ,fSpecies(-6)\r
-  ,fTriggerSlot(-1)\r
+  ,fTriggerSlot(0)\r
   ,fPt(-1.)\r
   ,fPhi(0.)\r
   ,fEta(0.)\r
@@ -92,7 +92,7 @@ AliTRDrecoTask::AliTRDrecoTask(const char *name, const char *title)
   ,fkMC(NULL)\r
   ,fkESD(NULL)\r
   ,fSpecies(-6)\r
-  ,fTriggerSlot(-1)\r
+  ,fTriggerSlot(0)\r
   ,fPt(-1.)\r
   ,fPhi(0.)\r
   ,fEta(0.)\r
@@ -723,6 +723,39 @@ Double_t AliTRDrecoTask::AliTRDrecoProjection::GetTrendValue(const Int_t mid, Do
 }\r
 \r
 //________________________________________________________\r
+TH2* AliTRDrecoTask::AliTRDrecoProjection::Projection2Dbin(Int_t bin)\r
+{\r
+// dumb 2D projection for bin including under/over flow. Default all [bin==-1]\r
+\r
+  TAxis *ax(fH->GetXaxis()), *ay(fH->GetYaxis()), *az(fH->GetZaxis());\r
+  Int_t nbins(az->GetNbins());\r
+  TH2F *h2(NULL);\r
+  if(bin<0) h2 = new TH2F(Form("%s_2D", fH->GetName()),\r
+                Form("%s;%s;%s;Entries", fH->GetTitle(), ax->GetTitle(), ay->GetTitle()),\r
+                ax->GetNbins(), ax->GetXmin(), ax->GetXmax(),\r
+                ay->GetNbins(), ay->GetXmin(), ay->GetXmax());\r
+  else h2 = new TH2F(Form("%s%d_2D", fH->GetName(), bin),\r
+                Form("%s | #it{%4.2f<=p_{t}[GeV/c]<%4.2f};%s;%s;Entries", fH->GetTitle(),\r
+                bin?fgPt[bin-1]:0., bin==nbins?9.99:fgPt[bin], ax->GetTitle(), ay->GetTitle()),\r
+                ax->GetNbins(), ax->GetXmin(), ax->GetXmax(),\r
+                ay->GetNbins(), ay->GetXmin(), ay->GetXmax());\r
+  printf("build %s\n", h2->GetName());\r
+  for(Int_t ix(1); ix<=ax->GetNbins(); ix++){\r
+    for(Int_t iy(1); iy<=ay->GetNbins(); iy++){\r
+      Int_t ibin = h2->GetBin(ix, iy);\r
+      for(Int_t iz(0); iz<=az->GetNbins()+1; iz++){\r
+        if(bin<0) h2->AddBinContent(ibin, fH->GetBinContent(ix, iy, iz));\r
+        else if(bin==iz){\r
+          h2->AddBinContent(ibin, fH->GetBinContent(ix, iy, iz));\r
+          break;\r
+        }\r
+      }\r
+    }\r
+  }\r
+  return h2;\r
+}\r
+\r
+//________________________________________________________\r
 TH2* AliTRDrecoTask::AliTRDrecoProjection::Projection2D(const Int_t nstat, const Int_t ncol, const Int_t mid, Bool_t del)\r
 {\r
 // build the 2D projection and adjust binning\r
index 3afd22d..94a3b4b 100644 (file)
@@ -53,6 +53,7 @@ public:
     TH3*      H() const { return fH;}\r
     void      Increment(Int_t bin[], Double_t v);\r
     TH2*      Projection2D(const Int_t nstat, const Int_t ncol, const Int_t mid=0, Bool_t del=kTRUE);\r
+    TH2*      Projection2Dbin(Int_t ibin=-1);\r
     void      SetRebinStrategy(Int_t n, Int_t rebx[], Int_t reby[]);\r
     void      SetShowRange(Float_t zm, Float_t zM, Float_t em=0., Float_t eM=0.) {fRange[0] = zm; fRange[1] = zM; fRange[2] = em; fRange[3] = eM;}\r
   private:\r
index ddd5868..ccaddcc 100644 (file)
@@ -625,7 +625,6 @@ TH1* AliTRDresolution::PlotTrackIn(const AliTRDtrackV1 *track)
 
   // down scale PID resolution
   Int_t spc(fSpecies); if(spc==3) spc=2; if(spc==-3) spc=-2; if(spc>3) spc=3; if(spc<-3) spc=-3;
-
   if(DebugLevel()>=3){
     Float_t tpc(fkESD->GetTPCdedx());
     Float_t tof(fkESD->GetTOFbeta());
@@ -653,7 +652,11 @@ TH1* AliTRDresolution::PlotTrackIn(const AliTRDtrackV1 *track)
   Double_t dphi = TMath::ATan(phit) - TMath::ASin(parR[2]);
 
   Double_t val[kNdim+2];
-  val[kBC]          = fTriggerSlot;//bc==0?0:(bc<0?-1.:1.);
+  Int_t v0pid(-2);
+  if(fkESD->IsElectron()) v0pid = -1;
+  else if(fkESD->IsPion()) v0pid = 0;
+  else if(fkESD->IsProton()) v0pid = 1;
+  val[kBC]          = fTriggerSlot?fTriggerSlot:v0pid;//bc==0?0:(bc<0?-1.:1.);
   Double_t alpha = (0.5+AliTRDgeometry::GetSector(fTracklet->GetDetector()))*AliTRDgeometry::GetAlpha(),
            cs    = TMath::Cos(alpha),
            sn    = TMath::Sin(alpha);
@@ -664,7 +667,8 @@ TH1* AliTRDresolution::PlotTrackIn(const AliTRDtrackV1 *track)
   val[kZrez]        = fTracklet->IsRowCross()?dz:(fTracklet->GetdQdl()*5.e-4 - 2.5);
   val[kPrez]        = dphi*TMath::RadToDeg();
   val[kSpeciesChgRC]= fTracklet->IsRowCross()?0:spc;
-  val[kPt]          = GetPtBin(fPt);
+  Float_t pz(0.); if(fTracklet->GetMomentum()-fPt>1.e-5) pz = TMath::Sqrt((fTracklet->GetMomentum()-fPt)*(fTracklet->GetMomentum()+fPt));
+  val[kPt]          = fTracklet->IsRowCross()?GetPtBin(pz):GetPtBin(fPt);
   val[kNdim]        = GetPtBin(fTracklet->GetMomentum());
   val[kNdim+1]      = dx;
   //val[kNdim+2]      = fEvent?fEvent->GetBunchFill():0;
@@ -729,7 +733,7 @@ TH1* AliTRDresolution::PlotMC(const AliTRDtrackV1 *track)
   AliTRDgeometry *geo(AliTRDinfoGen::Geometry());
   AliTRDseedV1 *fTracklet(NULL); TObjArray *clInfoArr(NULL);
   UChar_t s;
-  Double_t x, y, z, pt, dydx, dzdx, dzdl;
+  Double_t x, y, z, pt, dydx, dzdx/*, dzdl*/;
   Float_t pt0, p0, x0, y0, z0, dx, dy, dz, dydx0, dzdx0;
   Double_t covR[7]/*, cov[3]*/;
 
@@ -808,7 +812,7 @@ TH1* AliTRDresolution::PlotMC(const AliTRDtrackV1 *track)
     // track residuals
     dydx = fTracklet->GetYref(1);
     dzdx = fTracklet->GetZref(1);
-    dzdl = fTracklet->GetTgl();
+    //dzdl = fTracklet->GetTgl();
     y  = fTracklet->GetYref(0);
     dy = y - ymc;
     z  = fTracklet->GetZref(0);
@@ -1212,7 +1216,19 @@ void AliTRDresolution::MakeSummary()
       }
       if(nplot==9) cOut->SaveAs(Form("%s.gif", cOut->GetName()));
       else delete cOut;
-
+      // pt resolution plot
+      cOut = new TCanvas(Form("%s_%sTrkInPt", GetName(), typName[ityp]), "TrackIn Pt", Int_t(1.5*ny), Int_t(1.5*ny));
+      cOut->Divide(3,2, 1.e-5, 1.e-5);
+      for(Int_t ich(0), ipad(1); ich<2; ich++){
+        for(Int_t ispc(0); ispc<kNspc; ispc++){
+          p=cOut->cd(ipad++); p->SetRightMargin(0.1572581);p->SetTopMargin(0.08262712);
+          if(!(h2 = (TH2*)arr->FindObject(Form("H%sTrkInPt%s%d_2D", typName[ityp], chName[ich], ispc)))) continue;
+          h2->GetZaxis()->SetRangeUser(0.5, 1.); h2->Draw("colz");
+          MakeDetectorPlot(0);
+        }
+      }
+      cOut->SaveAs(Form("%s.gif", cOut->GetName()));
+      // MPV(Q) & <Q plots>
       const char *chQ[] = {"Q", "QS"};
       for(Int_t iq(0); iq<2; iq++){
         cOut = new TCanvas(Form("%s_%sTrkIn%s", GetName(), typName[ityp], chQ[iq]), "Track IN PID", Int_t(1.5*ny), Int_t(1.5*ny));
@@ -2125,7 +2141,7 @@ Bool_t AliTRDresolution::MakeProjectionTrackIn(Bool_t mc)
         php.AddLast(&hp[ih++]); np[isel]++;
       }
     }
-    isel++; // RC tracks
+    isel++; // RC projections
     hp[ih].Build(Form("H%sTrkInRCZ%c", mc?"MC":"", ptName[ipt]),
                   Form("TrackIn[RC]:: #Deltaz{%s}", ptCut[ipt]),
                   kEta, kPhi, kZrez, aa);
@@ -2148,10 +2164,21 @@ Bool_t AliTRDresolution::MakeProjectionTrackIn(Bool_t mc)
     hp[ih].SetRebinStrategy(nEtaPhi, rebinEtaPhiX, rebinEtaPhiY);
     php.AddLast(&hp[ih++]); np[isel]++;
   }
+  // pt projections
+  for(Int_t isp(0); isp<kNspc; isp++){
+    for(Int_t ich(0); ich<kNcharge; ich++){
+      isel++; // new selection
+      hp[ih].Build(Form("H%sTrkInPt%c%d", mc?"MC":"", chName[ich], isp),
+                    Form("TrackIn[%s%c]:: P_{t}[GeV/c]", spcName[isp], chSgn[ich]),
+                    kEta, kPhi, kPt, aa);
+      hp[ih].SetRebinStrategy(nEtaPhi, rebinEtaPhiX, rebinEtaPhiY);
+      php.AddLast(&hp[ih++]); //np[isel]++;
+    }
+  }
   AliInfo(Form("Build %3d 3D %s projections.", ih, mc?"MC":""));
 
   // fill projections
-  Int_t ch(0), pt(0), p(0), sp(1), rcBin(as?as->FindBin(0.):-1), ioff(0), joff(0), jsel(0);
+  Int_t ch(0), pt(0), p(0), sp(1), rcBin(as?as->FindBin(0.):-1), ioff(0), joff(0), jsel(0), ksel(0);
   AliTRDrecoProjection *pr0(NULL), *pr1(NULL);
   for (Long64_t ib(0); ib < H->GetNbins(); ib++) {
     v = H->GetBinContent(ib, coord);
@@ -2178,12 +2205,13 @@ Bool_t AliTRDresolution::MakeProjectionTrackIn(Bool_t mc)
     // global selection
     isel = pt*(kNspc*kNcharge+1); isel+=(ch==2?(kNspc*kNcharge):(sp*kNcharge+ch)); ioff = isel*(ax?4:3);
     jsel = p *(kNspc*kNcharge+1); jsel+=(ch==2?(kNspc*kNcharge):(sp*kNcharge+ch)); joff = jsel*(ax?4:3);
+    ksel = ch==2?0:nPt*(kNspc*kNcharge+1); ksel *= (ax?4:3); ksel+=sp*kNcharge+ch;
     if(ioff>=ih){
       AliError(Form("Wrong selection %d [%3d]", ioff, ih));
       return kFALSE;
     }
     if(!(pr0=(AliTRDrecoProjection*)php.At(ioff))) {
-      AliError(Form("Missing projection %d", ioff));
+      AliError(Form("Missing projection @ %d", ioff));
       return kFALSE;
     }
     if(ch<2){
@@ -2202,6 +2230,14 @@ Bool_t AliTRDresolution::MakeProjectionTrackIn(Bool_t mc)
       if(ch<2 && jh==2) ((AliTRDrecoProjection*)php.At(joff+jh))->Increment(coord, v); // special care for dQdl=f(p)
       else ((AliTRDrecoProjection*)php.At(ioff+jh))->Increment(coord, v); // all = f(p_t)
     }
+    if(ksel){
+      if(!(pr0 = (AliTRDrecoProjection*)php.At(ksel))){
+        AliError(Form("Missing P_t projection @ %d", ksel));
+        return kFALSE;
+      }
+      AliDebug(2, Form("Found %s for selection[%d] sp[%d] ch[%d]", pr0->H()->GetName(), ksel, sp, ch));
+      pr0->Increment(coord, v); // p_t spectra
+    }
   }
   if(HasDump3DFor(kTrackIn)){
     TDirectory *cwd = gDirectory;
@@ -2223,8 +2259,11 @@ Bool_t AliTRDresolution::MakeProjectionTrackIn(Bool_t mc)
   TH2 *h2(NULL); Int_t jh(0);
   for(; ih--; ){
     if(!hp[ih].H()) continue;
-    if(!(h2 = hp[ih].Projection2D(kNstat, kNcontours))) continue;
-    arr->AddAt(h2, jh++);
+    if(strstr(hp[ih].H()->GetName(), "TrkInPt")){
+      for(Int_t ipt(0); ipt<nPt; ipt++) arr->AddAt(hp[ih].Projection2Dbin(ipt), jh++);
+    } else {
+      if((h2 = hp[ih].Projection2D(kNstat, kNcontours))) arr->AddAt(h2, jh++);
+    }
   }
   // build combined performance plots
   // combine up the tree of projections
@@ -2516,6 +2555,54 @@ Bool_t AliTRDresolution::MakeProjectionTrackIn(Bool_t mc)
     pr0->H()->SetNameTitle(Form("H%sTrkInRCX", mc?"MC":""), "TrackIn[RC]:: #Deltax");
     if((h2 = pr0->Projection2D(kNstat, kNcontours, 1))) arr->AddAt(h2, jh++);
   }
+
+  // P_t processing
+  for(Int_t isp(0); isp<kNspc; isp++){
+    for(Int_t ich(0); ich<kNcharge; ich++){
+      h2 = new TH2F(Form("H%sTrkInPt%c%d_2D", mc?"MC":"", chName[ich], isp),
+                    Form("TrackIn[%s%c]:: <P_{t}>[GeV/c];%s;%s", spcName[isp], chSgn[ich], aa[2]->GetTitle(), aa[1]->GetTitle()),
+                    aa[2]->GetNbins(), aa[2]->GetXmin(), aa[2]->GetXmax(),
+                    aa[1]->GetNbins(), aa[1]->GetXmin(), aa[1]->GetXmax());
+      arr->AddAt(h2, jh++);
+      TH2 *h2pt[26]={NULL}, *h2s(NULL);
+      for(Int_t ipt(0); ipt<nPt; ipt++){
+        if(!(h2pt[ipt] = (TH2*)arr->FindObject(Form("H%sTrkInPt%c%d%d_2D", mc?"MC":"", chName[ich], isp, ipt)))){
+          AliWarning(Form("Missing \"H%sTrkInPt%c%d%d_2D\"", mc?"MC":"", chName[ich], isp, ipt));
+          continue;
+        }
+        if(!h2s) h2s = (TH2F*)h2pt[ipt]->Clone("h2s");
+        else h2s->Add(h2pt[ipt]);
+      }
+      if(!h2s) continue;
+      Int_t irebin(0), dxBin(1), dyBin(1);
+      while(irebin<nEtaPhi && (AliTRDrecoTask::GetMeanStat(h2s, .5, ">")<200)){
+        h2s->Rebin2D(rebinEtaPhiX[irebin], rebinEtaPhiY[irebin]);
+        dxBin*=rebinEtaPhiX[irebin];dyBin*=rebinEtaPhiY[irebin];irebin++;
+      }
+      AliDebug(2, Form("Rebin level[%d] @ chg[%d] spc[%d]. Binning[%2dx%2d]", irebin, ich, isp, h2s->GetNbinsX(), h2s->GetNbinsY()));
+
+      for(Int_t ix(1); ix<=aa[2]->GetNbins(); ix++){ // eta
+        for(Int_t iy(1); iy<=aa[1]->GetNbins(); iy++){ // phi
+          Float_t w[26]={0.}, sw(0.);
+          for(Int_t ipt(0); ipt<nPt; ipt++){
+            if(!h2pt[ipt]) continue;
+            w[ipt] = h2pt[ipt]->GetBinContent(ix, iy);
+            sw    += w[ipt];
+          }
+          if(sw<=0.) h2->SetBinContent(ix, iy, 0.);
+          else{
+            Float_t ptm(0.);
+            for(Int_t ipt(0); ipt<nPt; ipt++){
+              w[ipt]/=sw;
+              ptm   += w[ipt]*fgPt[ipt?ipt-1:0];
+            }
+            h2->SetBinContent(ix, iy, ptm);
+          }
+        }
+      }
+      PutTrendValue(Form("%sTrkInPt%c%d", mc?"MC":"", chName[ich], isp), GetMeanStat(h2, 0.01, ">"));
+    }
+  }
   AliInfo(Form("Done %3d 2D %s projections.", jh, mc?"MC":""));
   return kTRUE;
 }
@@ -2759,8 +2846,8 @@ Bool_t AliTRDresolution::PostProcess()
   fNRefFigures = 21;
 
   // TRACK RESOLUTION/PULLS
-  if(HasProcess(kTracklet)) if(!MakeProjectionTrack()) return kFALSE;
-  fNRefFigures+=16;
+//  if(HasProcess(kTracklet)) if(!MakeProjectionTrack()) return kFALSE;
+//  fNRefFigures+=16;
 
   // TRACK TRDin RESOLUTION/PULLS
   if(HasProcess(kTrackIn)) if(!MakeProjectionTrackIn(kTRUE)) return kFALSE;
@@ -3017,7 +3104,7 @@ Bool_t AliTRDresolution::FitTrack(const Int_t np, AliTrackPoint *points, Float_t
     z    = points[ip].GetZ();
     tilt = points[ip].GetCharge();
     y -= tilt*(-dzdx*dx + z - z0);
-    Float_t xyz[3] = {x, y, z}; points[ip].SetXYZ(xyz);
+    Float_t xyz[3] = {(Float_t)x, (Float_t)y, (Float_t)z}; points[ip].SetXYZ(xyz);
     yfitter.AddPoint(&dx, y, 1.);
   }
   if(yfitter.Eval() != 0) return kFALSE;
@@ -3097,14 +3184,14 @@ Bool_t AliTRDresolution::UseTrack(const Int_t np, const AliTrackPoint *points, F
 
   const Float_t kS(0.6), kM(0.2);
   TH1S h("h1", "", 100, -5.*kS, 5.*kS);
-  Float_t dy, dz, s, m;
+  Float_t dy/*, dz*/, s, m;
   for(Int_t ip(0); ip<np; ip++){
     if(points[ip].GetClusterType()) continue;
     Float_t x0(points[ip].GetX())
           ,y0(param[1] + param[3] * (x0 - param[0]))
-          ,z0(param[2] + param[4] * (x0 - param[0]));
+          /*,z0(param[2] + param[4] * (x0 - param[0]))*/;
     dy=points[ip].GetY() - y0; h.Fill(dy);
-    dz=points[ip].GetZ() - z0;
+    //dz=points[ip].GetZ() - z0;
   }
   TF1 fg("fg", "gaus", -5.*kS, 5.*kS);
   fg.SetParameter(1, 0.);
index 01db513..b9f0e02 100644 (file)
@@ -127,7 +127,7 @@ Int_t AliTRDtrackInfo::AliMCinfo::GetPID() const
 
 //___________________________________________________
 AliTRDtrackInfo::AliESDinfo::AliESDinfo()
-  :fHasV0(0)
+  :fSteer(0)
   ,fId(-1)
   ,fStatus(0)
   ,fKinkIndex(0)
@@ -156,7 +156,7 @@ AliTRDtrackInfo::AliESDinfo::AliESDinfo()
 
 //___________________________________________________
 AliTRDtrackInfo::AliESDinfo::AliESDinfo(const AliESDinfo &esd)
-  :fHasV0(esd.fHasV0)
+  :fSteer(esd.fSteer)
   ,fId(esd.fId)
   ,fStatus(esd.fStatus)
   ,fKinkIndex(esd.fKinkIndex)
@@ -312,7 +312,7 @@ AliTRDtrackInfo::AliESDinfo& AliTRDtrackInfo::AliESDinfo::operator=(const AliESD
   //
 
   if(this == &esd) return *this;
-  fHasV0       = esd.fHasV0;
+  fSteer       = esd.fSteer;
   fId          = esd.fId;
   fStatus      = esd.fStatus;
   fKinkIndex   = esd.fKinkIndex;
index 6a73886..ab497c1 100644 (file)
@@ -31,13 +31,18 @@ public:
   class AliESDinfo{
     friend class AliTRDtrackInfo;  // Friend class
   public:
+    enum EESDinfo{
+       kV0       = 0
+      ,kElectron = 1
+      ,kPion     = 2
+      ,kProton   = 3
+    };
     AliESDinfo();
     AliESDinfo(const AliESDinfo &esd);
     virtual ~AliESDinfo();
     AliESDinfo& operator=(const AliESDinfo &esd);
     void Delete(const Option_t *);
     Float_t     Eta() const                      { return fEta;}
-    Bool_t      HasV0() const                    { return fHasV0;}
     Int_t       GetId() const                    { return fId;}
     ULong_t     GetStatus() const                { return fStatus;}
     Int_t       GetKinkIndex() const             { return fKinkIndex;}
@@ -56,15 +61,23 @@ public:
     AliExternalTrackParam* GetTPCoutParam() const { return fTPCout;}
     const Int_t* GetV0pid() const                { return &fTRDv0pid[0];}
     Int_t       GetV0pid(Int_t i) const          { return fTRDv0pid[i];}
+    Bool_t      HasV0() const                    { return TESTBIT(fSteer, kV0);}
+    Bool_t      IsElectron() const               { return TESTBIT(fSteer, kElectron);}
+    Bool_t      IsPion() const                   { return TESTBIT(fSteer, kPion);}
+    Bool_t      IsProton() const                 { return TESTBIT(fSteer, kProton);}
     Float_t     Phi() const                      { return fPhi;}
     Float_t     Pt() const                       { return fPt;}
+    void        SetElectron(Bool_t e=kTRUE)      { e?SETBIT(fSteer, kElectron):CLRBIT(fSteer, kElectron);}
+    void        SetPion(Bool_t e=kTRUE)          { e?SETBIT(fSteer, kPion):CLRBIT(fSteer, kPion);}
+    void        SetProton(Bool_t e=kTRUE)        { e?SETBIT(fSteer, kProton):CLRBIT(fSteer, kProton);}
+    void        SetV0(Bool_t v=kTRUE)            { v?SETBIT(fSteer, kV0):CLRBIT(fSteer, kV0);}
     void        SetOuterParam(const AliExternalTrackParam *op);
     void        SetITSoutParam(const AliExternalTrackParam *op);
     void        SetTPCoutParam(const AliExternalTrackParam *op);
     void        SetTrackPointArray(const AliTrackPointArray *tps);
 
   protected:
-    UChar_t     fHasV0;                   // v0 bit
+    UChar_t     fSteer;                   // bit map
     Int_t       fId;                      // ESD track id
     ULong_t     fStatus;                  // ESD track status
     Int_t       fKinkIndex;               // ESD kink index
@@ -154,6 +167,9 @@ public:
   Bool_t             HasESDtrack() const              { return ((fTRDtrack != 0x0) ||(fESD.fOP != 0));}
   Bool_t             HasMCinfo() const                { return (Bool_t)fMC; }
 
+  void               SetElectron(Bool_t c = kTRUE)    { fESD.SetElectron(c);}
+  void               SetPion(Bool_t c = kTRUE)        { fESD.SetPion(c);}
+  void               SetProton(Bool_t c = kTRUE)      { fESD.SetProton(c);}
   void               SetCurved(Bool_t curv = kTRUE)   { SetBit(kCurv, curv);}
   void               SetLabel(Int_t lab)              { if(fMC) fMC->fLabel = lab; }
   void               SetTRDlabel(Int_t lab)           { if(fMC) fMC->fTRDlabel = lab; }
@@ -180,7 +196,7 @@ public:
   void               SetESDphi(Float_t phi)           { fESD.fPhi = phi;}
   void               SetESDpt(Float_t pt)             { fESD.fPt = pt;}
   inline void        SetV0pid(Int_t *);
-  void               SetV0(Bool_t v0=kTRUE)           { fESD.fHasV0 = v0;}
+  void               SetV0(Bool_t v0=kTRUE)           { fESD.SetV0(v0);}
   
 private:
     enum{
index 4efa824..e4f489d 100644 (file)
@@ -197,6 +197,7 @@ TH1* AliTRDtrendingManager::MakeTrends(const char *fileList, TObjArray *dump)
       }
       if(tv->GetVal()<-998. ||
          (strstr(TV->GetName(), "TRDcheckDET")&&TMath::Abs(tv->GetVal())<1.e-5) ||
+         (strstr(TV->GetName(), "TRDefficiency")&&tv->GetVal()<1.e-5) ||
          (!(strcmp(TV->GetName(), "TRDcheckDET_ChargeTracklet"))&&TMath::Abs(tv->GetVal())<1.e1)) continue;
       if(IsRelativeMeanSigma()){
         (*tv)/=(*TV);
index 1f85e4b..ad81e14 100644 (file)
@@ -239,7 +239,7 @@ AliTRDv0Info::AliTRDv0Info()
 
 //_________________________________________________
 AliTRDv0Info::AliTRDv0Info(const AliTRDv0Info &ref)
-  : TObject()
+  : TObject((TObject&)ref)
   ,fQuality(ref.fQuality)
   ,fDCA(ref.fDCA)
   ,fPointingAngle(ref.fPointingAngle)
@@ -733,6 +733,7 @@ Int_t AliTRDv0Info::Quality(const AliESDv0 *const esdv0)
   fQuality = 1;
   return fQuality;
 }
+
 //________________________________________________________________
 Bool_t AliTRDv0Info::V0SignCheck(){
   //
@@ -746,6 +747,7 @@ Bool_t AliTRDv0Info::V0SignCheck(){
 
   return kTRUE;
 }
+
 //___________________________________________________________________
 Bool_t AliTRDv0Info::Armenteros(const AliESDv0 *esdv0, Int_t decay){
   //
@@ -815,10 +817,12 @@ Bool_t AliTRDv0Info::Armenteros(const AliESDv0 *esdv0, Int_t decay){
   }
   return kTRUE;
 }
+
 //_________________________________________________
 Int_t AliTRDv0Info::GetPID(Int_t ipart, AliTRDtrackInfo *track)
 {
   // Decides if track is accepted for one of the reference data samples
+
   Int_t cutCode = -99;
   if(!(track)) {
     AliError("No track info");
@@ -864,10 +868,7 @@ Int_t AliTRDv0Info::GetPID(Int_t ipart, AliTRDtrackInfo *track)
   //specific cut criteria :
   if(ipart == AliPID::kProton) {
     if((fInvMass[kK0s] < fUpInvMass[kK0s][iPSlot]) && (fInvMass[kK0s] > fDownInvMass[kK0s])) return -11;//explicit exclusion of K0s decays
-
-    if(fOpenAngle < (0.3 - 0.2*fV0Momentum))return -9;
-
+    if(fOpenAngle < (0.3 - 0.2*fV0Momentum)) return -9;
 
     //for proton sample: separate treatment of Lamba and Anti-Lambda decays:
     //for Anti-Lambda:
@@ -876,50 +877,40 @@ Int_t AliTRDv0Info::GetPID(Int_t ipart, AliTRDtrackInfo *track)
     //if((fDetPID[kNeg][kTPC][AliPID::kProton] > fDownTPCPIDneg[AliPID::kProton]) && (fDetPID[kPos][kTPC][AliPID::kPion] > fDownTPCPIDpos[AliPID::kPion])){
     if((TPCdEdxCuts(ipart, track))){//momentary solution: direct cut on TPC dE/dx
       if(fNindex == trackID) {//we're only interested in the anti-proton
-       if(fArmenteros[kAntiLambda]){//Armenteros condition has to be fulfilled   
-         if(fChi2ndf[kAntiLambda] < fUpChi2ndf[kAntiLambda]){//Kalman filter Chi2/NDF not allowed to be too large
-           if((fInvMass[kAntiLambda] < fUpInvMass[kAntiLambda][iPSlot]) && (fInvMass[kAntiLambda] > fDownInvMass[kAntiLambda])){  
-        return 1;
-           } else cutCode = -15;
-         }
-         else cutCode =-14;
-       }
-       else cutCode = -13;
+        if(fArmenteros[kAntiLambda]){//Armenteros condition has to be fulfilled
+          if(fChi2ndf[kAntiLambda] < fUpChi2ndf[kAntiLambda]){//Kalman filter Chi2/NDF not allowed to be too large
+            if((fInvMass[kAntiLambda] < fUpInvMass[kAntiLambda][iPSlot]) && (fInvMass[kAntiLambda] > fDownInvMass[kAntiLambda])){
+              return 1;
+            } else cutCode = -15;
+          } else cutCode =-14;
+        } else cutCode = -13;
       }
-    }
-    else cutCode = -12;
+    } else cutCode = -12;
     //for Lambda:
     //TPC PID likelihoods high enough for pi- and proton ; invariant mass calculated accordingly
     //if((fComPID[kNeg][AliPID::kPion] > fDownComPIDnegPart[AliPID::kPion]) && (fComPID[kPos][AliPID::kProton] > fDownComPIDpos[AliPID::kProton])) {
     //if((fDetPID[kNeg][kTPC][AliPID::kPion] > fDownTPCPIDneg[AliPID::kPion]) && (fDetPID[kPos][kTPC][AliPID::kProton] > fDownTPCPIDpos[AliPID::kProton])){
     if((TPCdEdxCuts(ipart, track))){//momentary solution: direct TPC dE/dx cuts
       if(fPindex == trackID) {
-       if(fArmenteros[kLambda]){
-         if(fChi2ndf[kLambda] < fUpChi2ndf[kLambda]){
-           if((fInvMass[kLambda] < fUpInvMass[kLambda][iPSlot]) && (fInvMass[kLambda] > fDownInvMass[kLambda])){ 
-        return 1;
-           } else cutCode = -15;
-         }
-         else cutCode = -14;
-       }
-       else cutCode = -13;
+        if(fArmenteros[kLambda]){
+          if(fChi2ndf[kLambda] < fUpChi2ndf[kLambda]){
+            if((fInvMass[kLambda] < fUpInvMass[kLambda][iPSlot]) && (fInvMass[kLambda] > fDownInvMass[kLambda])){
+              return 1;
+            } else cutCode = -15;
+          } else cutCode = -14;
+        } else cutCode = -13;
       }
-    }
-    else cutCode = -12;
+    } else cutCode = -12;
     return cutCode;
   }
  
   //for K0s decays: equal TPC PID likelihood criteria for both daughters ; invariant mass calculated postulating two pions
   if(ipart == AliPID::kPion) {
-    
-    if(fOpenAngle < (1.0/(fV0Momentum + 0.3) - 0.1))
-      return -9;
-    
+    if(fOpenAngle < (1.0/(fV0Momentum + 0.3) - 0.1)) return -9;
     //explicit exclusion of Lambda decays
     if((fInvMass[kLambda] < fUpInvMass[kLambda][iPSlot]) && (fInvMass[kLambda] > fDownInvMass[kLambda])) return -11;
     //explicit exclusion of Anti-Lambda decays
     if((fInvMass[kAntiLambda] < fUpInvMass[kAntiLambda][iPSlot]) && (fInvMass[kAntiLambda] > fDownInvMass[kAntiLambda])) return -11;
-    
     //if((fDetPID[kNeg][kTPC][ipart] < fDownTPCPIDneg[ipart]) || (fDetPID[kPos][kTPC][ipart] < fDownTPCPIDpos[ipart])) return -12;
     if(!(TPCdEdxCuts(ipart, track))){//momentary solution: direct TPC dE/dx cuts
       return -12;
@@ -939,22 +930,14 @@ Int_t AliTRDv0Info::GetPID(Int_t ipart, AliTRDtrackInfo *track)
     if(!(TPCdEdxCuts(ipart, track))){//momentary solution for direct TPC dE/dx cut
       return -12;
     }
-    
   }
   
   //Armenteros-Polanski cut
   if(!(fArmenteros[iDecay])) return -13;
-  
   //Kalman filter Chi2/NDF cut
   if(fChi2ndf[iDecay] > fUpChi2ndf[iDecay]) return -14;
-
   //Invariant mass cut for K0s and photons, assuming two pions/two electrons as daughters:
-  if((fInvMass[iDecay] > fUpInvMass[iDecay][iPSlot]) || (fInvMass[iDecay] < fDownInvMass[iDecay])) {
-    return -15;
-    
-  }
+  if((fInvMass[iDecay] > fUpInvMass[iDecay][iPSlot]) || (fInvMass[iDecay] < fDownInvMass[iDecay])) return -15;
    
   return 1;
 }
@@ -964,16 +947,17 @@ Int_t AliTRDv0Info::GetPID(Int_t ipart, AliTRDtrackInfo *track)
 void AliTRDv0Info::Print(Option_t *opt) const
 {
   //prints text for debugging etc.
-  printf("V0 P[%d] N[%d]\n", fPindex, fNindex);
-  printf("  DCA[%5.3f] Radius[%5.3f]\n", fDCA, fRadius);
-  printf("  Angles : Pointing[%5.3f] Open[%5.3f] Psi[%5.3f]\n", fPointingAngle, fOpenAngle, fPsiPair);
+  printf("V0 legs :: %4d[+] %4d[-]\n", fPindex, fNindex);
+  printf("  Decay :: Gamma[%c] K0s[%c] Lambda[%c] AntiLambda[%c]\n",
+    IsDecay(kGamma)?'y':'n', IsDecay(kK0s)?'y':'n', IsDecay(kLambda)?'y':'n', IsDecay(kAntiLambda)?'y':'n');
+  printf("  Kine  :: DCA[%5.3f] Radius[%5.3f]\n", fDCA, fRadius);
+  printf("  Angle :: Pointing[%5.3f] Open[%5.3f] Psi[%5.3f]\n", fPointingAngle, fOpenAngle, fPsiPair);
   if(strcmp(opt, "a")!=0) return;
-  printf("  Reconstructed PID\n"
-         "  sgn spec   ITS   TPC   TOF   COM\n");
+  printf("  PID   ::\n"
+         "             ITS   TPC   TOF   COM\n");
   for(Int_t idt=0; idt<kNDaughters; idt++){
-    printf("   %c", idt?'-':'+');
     for(Int_t is(0); is<AliPID::kSPECIES; is++){ 
-      printf("%s%s%s", is==0?"   ":"       ", AliPID::ParticleShortName(is), (is==1||is==2)?"  ":"   ");
+      printf("      %s%c%s", AliPID::ParticleShortName(is), idt?'-':'+', (is==1||is==2)?"  ":"   ");
       for(Int_t id(0); id<kNDetectors; id++){
         printf("%5.1f ", 1.e2*fDetPID[idt][id][is]);
       }
index f005131..a694d90 100644 (file)
@@ -68,170 +68,154 @@ public:
   AliTRDv0Info(const AliTRDv0Info &ref);
   virtual ~AliTRDv0Info(){}
   
-
-  Int_t GetQuality() const {return fQuality;}
-  Float_t GetDCA() const {return fDCA;}
-  Float_t GetPointingAngle() const {return fPointingAngle;}
-  Float_t GetOpenAngle() const {return fOpenAngle;}
-  Float_t GetPsiPair() const {return fPsiPair;}
-  Float_t GetRadius() const {return fRadius;}
-  Float_t GetV0Momentum() const {return fV0Momentum;}
-  Double_t GetInvMass(Int_t iDecay) const {return fInvMass[iDecay];}
-  Float_t GetDetPID(Int_t iDaughter, Int_t iDetector, Int_t iSpecies) const {return fDetPID[iDaughter][iDetector][iSpecies];}
-  Float_t GetComPID(Int_t iDaughter, Int_t iSpecies) const {return fComPID[iDaughter][iSpecies];}
-  Float_t GetTPCdEdx(Int_t iDaughter) const {return fTPCdEdx[iDaughter];}
-  Float_t GetChi2ndf(Int_t decay) const {return fChi2ndf[decay];}
+  Int_t         GetQuality() const {return fQuality;}
+  Float_t       GetDCA() const {return fDCA;}
+  Float_t       GetPointingAngle() const {return fPointingAngle;}
+  Float_t       GetOpenAngle() const {return fOpenAngle;}
+  Float_t       GetPsiPair() const {return fPsiPair;}
+  Float_t       GetRadius() const {return fRadius;}
+  Float_t       GetV0Momentum() const {return fV0Momentum;}
+  Double_t      GetInvMass(Int_t iDecay) const {return fInvMass[iDecay];}
+  Float_t       GetDetPID(Int_t iDaughter, Int_t iDetector, Int_t iSpecies) const {return fDetPID[iDaughter][iDetector][iSpecies];}
+  Float_t       GetComPID(Int_t iDaughter, Int_t iSpecies) const {return fComPID[iDaughter][iSpecies];}
+  Float_t       GetTPCdEdx(Int_t iDaughter) const {return fTPCdEdx[iDaughter];}
+  Float_t       GetChi2ndf(Int_t decay) const {return fChi2ndf[decay];}
   
   //Get Cut values:
-  
-  Float_t GetUpDCA(Int_t iDecay) const {return fUpDCA[iDecay];}
-  Float_t GetUpPointingAngle(Int_t iDecay) const {return fUpPointingAngle[iDecay];}
-  Float_t GetUpOpenAngle(Int_t iDecay) const {return fUpOpenAngle[iDecay];}
-  Float_t GetDownOpenAngle(Int_t iDecay) const {return fDownOpenAngle[iDecay];}
-  Float_t GetUpPsiPair(Int_t iDecay) const {return fUpPsiPair[iDecay];}
-  Float_t GetDownPsiPair(Int_t iDecay) const {return fDownPsiPair[iDecay];}
-  Float_t GetUpRadius(Int_t iDecay) const {return fUpRadius[iDecay];}
-  Float_t GetDownRadius(Int_t iDecay) const {return fDownRadius[iDecay];}
-  Double_t GetUpInvMass(Int_t iDecay, Int_t iMomentum) const {return fUpInvMass[iDecay][iMomentum];}
-  Double_t GetDownInvMass(Int_t iDecay) const {return fDownInvMass[iDecay];}
-  Float_t GetDownTPCPIDneg(Int_t iPart) const {return fDownTPCPIDneg[iPart];}
-  Float_t GetDownTPCPIDpos(Int_t iPart) const {return fDownTPCPIDpos[iPart];}
-  Float_t GetDownComPIDneg(Int_t iPart) const {return fDownComPIDneg[iPart];}
-  Float_t GetDownComPIDpos(Int_t iPart) const {return fDownComPIDpos[iPart];}
-  Float_t GetDownComPIDnegPart(Int_t iPart) const {return fDownComPIDnegPart[iPart];}
-  Float_t GetDownComPIDposPart(Int_t iPart) const {return fDownComPIDposPart[iPart];}
-  
-  
-  Int_t  GetPID(Int_t ipart, AliTRDtrackInfo *track);
-  Int_t  HasTrack(const AliTRDtrackInfo * const track) const;
-  Int_t  HasTrack(Int_t ti) const;
-  AliESDtrack *GetV0Daughter(Int_t sign); //Get positive of negative daughter of decay
-  
-  void   Print(Option_t *opt="") const;
-  
-  void   SetMagField(Float_t b) {fMagField = b;}
-  void   SetV0tracks(AliESDtrack *p, AliESDtrack *n);
-  void SetInputEvent(AliVEvent *e)      { fInputEvent = e; };
-  void SetPrimaryVertex(AliKFVertex *v) { fPrimaryVertex = v; };
+  Float_t       GetUpDCA(Int_t iDecay) const {return fUpDCA[iDecay];}
+  Float_t       GetUpPointingAngle(Int_t iDecay) const {return fUpPointingAngle[iDecay];}
+  Float_t       GetUpOpenAngle(Int_t iDecay) const {return fUpOpenAngle[iDecay];}
+  Float_t       GetDownOpenAngle(Int_t iDecay) const {return fDownOpenAngle[iDecay];}
+  Float_t       GetUpPsiPair(Int_t iDecay) const {return fUpPsiPair[iDecay];}
+  Float_t       GetDownPsiPair(Int_t iDecay) const {return fDownPsiPair[iDecay];}
+  Float_t       GetUpRadius(Int_t iDecay) const {return fUpRadius[iDecay];}
+  Float_t       GetDownRadius(Int_t iDecay) const {return fDownRadius[iDecay];}
+  Double_t      GetUpInvMass(Int_t iDecay, Int_t iMomentum) const {return fUpInvMass[iDecay][iMomentum];}
+  Double_t      GetDownInvMass(Int_t iDecay) const {return fDownInvMass[iDecay];}
+  Float_t       GetDownTPCPIDneg(Int_t iPart) const {return fDownTPCPIDneg[iPart];}
+  Float_t       GetDownTPCPIDpos(Int_t iPart) const {return fDownTPCPIDpos[iPart];}
+  Float_t       GetDownComPIDneg(Int_t iPart) const {return fDownComPIDneg[iPart];}
+  Float_t       GetDownComPIDpos(Int_t iPart) const {return fDownComPIDpos[iPart];}
+  Float_t       GetDownComPIDnegPart(Int_t iPart) const {return fDownComPIDnegPart[iPart];}
+  Float_t       GetDownComPIDposPart(Int_t iPart) const {return fDownComPIDposPart[iPart];}
+  
+  Int_t         GetPID(Int_t ipart, AliTRDtrackInfo *track);
+  AliESDtrack*  GetV0Daughter(Int_t sign); //Get positive of negative daughter of decay
+
+  Int_t         HasTrack(const AliTRDtrackInfo * const track) const;
+  Int_t         HasTrack(Int_t ti) const;
+  Bool_t        IsDecay(Int_t type) const {if(type<0||type>=Int_t(kNDecays)) return kFALSE; return TestBit(BIT(14+type));}
+
+  void          Print(Option_t *opt="") const;
+  
+  void          SetMagField(Float_t b) {fMagField = b;}
+  void          SetV0tracks(AliESDtrack *p, AliESDtrack *n);
+  void          SetInputEvent(AliVEvent *e)      { fInputEvent = e; };
+  void          SetPrimaryVertex(AliKFVertex *v) { fPrimaryVertex = v; };
   
   //Set values of measured/calculated variables:
-  void SetQuality(Int_t SQuality){fQuality = SQuality;}
-  void SetDCA(Float_t SDCA){fDCA = SDCA;}
-  void SetPointingAngle(Float_t SPointingAngle){fPointingAngle = SPointingAngle;}
-  void SetOpenAngle(Float_t SOpenAngle){fOpenAngle = SOpenAngle;}
-  void SetPsiPair(Float_t SPsiPair){fPsiPair = SPsiPair;}
-  void SetRadius(Float_t SRadius){fRadius = SRadius;}
-  void SetInvMass(Int_t iDecay, Float_t SInvMass){fInvMass[iDecay] = SInvMass;}
-  void SetDetPID(Int_t iDaughter, Int_t iDetector, Int_t iSpecies, Float_t SDetPID){fDetPID[iDaughter][iDetector][iSpecies] = SDetPID;}
-  void SetComPID(Int_t iDaughter, Int_t iSpecies, Float_t SComPID){fComPID[iDaughter][iSpecies] = SComPID;}
-  void SetTPCdEdx(Int_t iDaughter, Float_t STpcdEdx){fTPCdEdx[iDaughter] = STpcdEdx;}
-  void SetV0Momentum(Float_t SV0Momentum){fV0Momentum = SV0Momentum;}
-  void SetChi2ndf(Int_t decay, Float_t SChi2ndf){fChi2ndf[decay]=SChi2ndf;}
-
-//____________________________________________________________
- //Set cut values:
-
-  void SetUpDCA(Int_t iDecay, Float_t UpDCA){fUpDCA[iDecay] = UpDCA;}
-  void SetUpPointingAngle(Int_t iDecay, Float_t UpPointingAngle){fUpPointingAngle[iDecay] = UpPointingAngle;}
-  void SetUpOpenAngle(Int_t iDecay, Float_t UpOpenAngle){fUpOpenAngle[iDecay] = UpOpenAngle;}
-  void SetDownOpenAngle(Int_t iDecay, Float_t DownOpenAngle){fDownOpenAngle[iDecay] = DownOpenAngle;}
-  void SetUpPsiPair(Int_t iDecay, Float_t UpPsiPair){fUpPsiPair[iDecay] = UpPsiPair;}
-  void SetDownPsiPair(Int_t iDecay, Float_t DownPsiPair){fDownPsiPair[iDecay] = DownPsiPair;}
-  void SetUpRadius(Int_t iDecay, Float_t UpRadius){fUpRadius[iDecay] = UpRadius;}
-  void SetDownRadius(Int_t iDecay, Float_t DownRadius){fDownRadius[iDecay] = DownRadius;}
-  void SetUpInvMass(Int_t iDecay, Int_t iMomentum, Double_t UpInvMass){fUpInvMass[iDecay][iMomentum] = UpInvMass;}
-  void SetDownInvMass(Int_t iDecay, Double_t DownInvMass){fDownInvMass[iDecay] = DownInvMass;}
-  void SetDownTPCPIDneg(Int_t iPart, Double_t DownTPCPIDneg){fDownTPCPIDneg[iPart] = DownTPCPIDneg;}
-  void SetDownTPCPIDpos(Int_t iPart, Double_t DownTPCPIDpos){fDownTPCPIDpos[iPart] = DownTPCPIDpos;}
-  void SetDownComPIDneg(Int_t iPart, Double_t DownComPIDneg){fDownComPIDneg[iPart] = DownComPIDneg;}
-  void SetDownComPIDpos(Int_t iPart, Double_t DownComPIDpos){fDownComPIDpos[iPart] = DownComPIDpos;}
-  void SetDownComPIDnegPart(Int_t iPart, Double_t DownComPIDnegPart){fDownComPIDnegPart[iPart] = DownComPIDnegPart;}
-  void SetDownComPIDposPart(Int_t iPart, Double_t DownComPIDposPart){fDownComPIDposPart[iPart] = DownComPIDposPart;}
-  
-  void SetV0Info(const AliESDv0 *v0);//gets most of the variables below
-
+  void          SetQuality(Int_t SQuality){fQuality = SQuality;}
+  void          SetDCA(Float_t SDCA){fDCA = SDCA;}
+  void          SetPointingAngle(Float_t SPointingAngle){fPointingAngle = SPointingAngle;}
+  void          SetOpenAngle(Float_t SOpenAngle){fOpenAngle = SOpenAngle;}
+  void          SetPsiPair(Float_t SPsiPair){fPsiPair = SPsiPair;}
+  void          SetRadius(Float_t SRadius){fRadius = SRadius;}
+  void          SetInvMass(Int_t iDecay, Float_t SInvMass){fInvMass[iDecay] = SInvMass;}
+  void          SetDetPID(Int_t iDaughter, Int_t iDetector, Int_t iSpecies, Float_t SDetPID){fDetPID[iDaughter][iDetector][iSpecies] = SDetPID;}
+  void          SetComPID(Int_t iDaughter, Int_t iSpecies, Float_t SComPID){fComPID[iDaughter][iSpecies] = SComPID;}
+  void          SetTPCdEdx(Int_t iDaughter, Float_t STpcdEdx){fTPCdEdx[iDaughter] = STpcdEdx;}
+  void          SetV0Momentum(Float_t SV0Momentum){fV0Momentum = SV0Momentum;}
+  void          SetChi2ndf(Int_t decay, Float_t SChi2ndf){fChi2ndf[decay]=SChi2ndf;}
 
+ //Set cut values:
+  void          SetUpDCA(Int_t iDecay, Float_t UpDCA){fUpDCA[iDecay] = UpDCA;}
+  void          SetUpPointingAngle(Int_t iDecay, Float_t UpPointingAngle){fUpPointingAngle[iDecay] = UpPointingAngle;}
+  void          SetUpOpenAngle(Int_t iDecay, Float_t UpOpenAngle){fUpOpenAngle[iDecay] = UpOpenAngle;}
+  void          SetDownOpenAngle(Int_t iDecay, Float_t DownOpenAngle){fDownOpenAngle[iDecay] = DownOpenAngle;}
+  void          SetUpPsiPair(Int_t iDecay, Float_t UpPsiPair){fUpPsiPair[iDecay] = UpPsiPair;}
+  void          SetDownPsiPair(Int_t iDecay, Float_t DownPsiPair){fDownPsiPair[iDecay] = DownPsiPair;}
+  void          SetUpRadius(Int_t iDecay, Float_t UpRadius){fUpRadius[iDecay] = UpRadius;}
+  void          SetDownRadius(Int_t iDecay, Float_t DownRadius){fDownRadius[iDecay] = DownRadius;}
+  void          SetUpInvMass(Int_t iDecay, Int_t iMomentum, Double_t UpInvMass){fUpInvMass[iDecay][iMomentum] = UpInvMass;}
+  void          SetDownInvMass(Int_t iDecay, Double_t DownInvMass){fDownInvMass[iDecay] = DownInvMass;}
+  void          SetDownTPCPIDneg(Int_t iPart, Double_t DownTPCPIDneg){fDownTPCPIDneg[iPart] = DownTPCPIDneg;}
+  void          SetDownTPCPIDpos(Int_t iPart, Double_t DownTPCPIDpos){fDownTPCPIDpos[iPart] = DownTPCPIDpos;}
+  void          SetDownComPIDneg(Int_t iPart, Double_t DownComPIDneg){fDownComPIDneg[iPart] = DownComPIDneg;}
+  void          SetDownComPIDpos(Int_t iPart, Double_t DownComPIDpos){fDownComPIDpos[iPart] = DownComPIDpos;}
+  void          SetDownComPIDnegPart(Int_t iPart, Double_t DownComPIDnegPart){fDownComPIDnegPart[iPart] = DownComPIDnegPart;}
+  void          SetDownComPIDposPart(Int_t iPart, Double_t DownComPIDposPart){fDownComPIDposPart[iPart] = DownComPIDposPart;}
+  void          SetV0Info(const AliESDv0 *v0);//gets most of the variables below
+  void          SetDecay(Int_t type, Bool_t s=kTRUE) {SetBit(BIT(14+type), s);}
 
 private:
   AliTRDv0Info& operator=(const AliTRDv0Info&);
 
-  void GetDetectorPID();//operating with likelihood values of different detectors
-  void CombinePID();//Bayesian combination of TPC and TOF likelihoods
-  Bool_t TPCdEdxCuts(Int_t part, const AliTRDtrackInfo * const track);//direct cuts on TPC dE/dx
-
-  Bool_t GetTPCdEdx();//TPC dE/dx values from both tracks
-  Int_t Quality(const AliESDv0 * const esdv0);//checks for track/vertex quality criteria
-  Double_t InvMass(Int_t part1, Int_t part2, const AliESDv0 *esdv0) const;//invariant mass of mother
-  Float_t PsiPair(const AliESDv0 *esdv0);//angle between daughters in plane perpendicular to magnetic field (characteristically around zero for conversions)
-  Float_t OpenAngle(const AliESDv0 *esdv0);//opening angle between V0 daughters; close to zero for conversions
-  Float_t Radius(const AliESDv0 *esdv0);//distance of secondary to primary vertex in x-y-plane 
-  Float_t DCA() const {return fDCA;}//distance of closest approach between supposed daughter tracks
-  Float_t PointingAngle() const {return fPointingAngle;}//pointing angle: between vector from primary to secondary vertex and reconstructed momentum of V0 mother particle
-  Float_t V0Momentum(const AliESDv0 *esdv0) const;//reconstructed momentum of V0 mother particle
-  Bool_t V0SignCheck();//checks if daughters have opposite signs
-  Bool_t  Armenteros(const AliESDv0 *esdv0, Int_t species);//the famous Armenteros-Polanski cut
-  Double_t KFChi2ndf(Int_t part1, Int_t part2,Int_t decay);//Chi2ndf from KF
-  AliKFParticle *CreateMotherParticle(const AliESDtrack *pdaughter, const AliESDtrack *ndaughter, Int_t pspec, Int_t nspec);//Mother Particle from KF
+  void          GetDetectorPID();//operating with likelihood values of different detectors
+  void          CombinePID();//Bayesian combination of TPC and TOF likelihoods
+  Bool_t        TPCdEdxCuts(Int_t part, const AliTRDtrackInfo * const track);//direct cuts on TPC dE/dx
+
+  Bool_t        GetTPCdEdx();//TPC dE/dx values from both tracks
+  Int_t         Quality(const AliESDv0 * const esdv0);//checks for track/vertex quality criteria
+  Double_t      InvMass(Int_t part1, Int_t part2, const AliESDv0 *esdv0) const;//invariant mass of mother
+  Float_t       PsiPair(const AliESDv0 *esdv0);//angle between daughters in plane perpendicular to magnetic field (characteristically around zero for conversions)
+  Float_t       OpenAngle(const AliESDv0 *esdv0);//opening angle between V0 daughters; close to zero for conversions
+  Float_t       Radius(const AliESDv0 *esdv0);//distance of secondary to primary vertex in x-y-plane 
+  Float_t       DCA() const {return fDCA;}//distance of closest approach between supposed daughter tracks
+  Float_t       PointingAngle() const {return fPointingAngle;}//pointing angle: between vector from primary to secondary vertex and reconstructed momentum of V0 mother particle
+  Float_t       V0Momentum(const AliESDv0 *esdv0) const;//reconstructed momentum of V0 mother particle
+  Bool_t        V0SignCheck();//checks if daughters have opposite signs
+  Bool_t        Armenteros(const AliESDv0 *esdv0, Int_t species);//the famous Armenteros-Polanski cut
+  Double_t      KFChi2ndf(Int_t part1, Int_t part2,Int_t decay);//Chi2ndf from KF
+  AliKFParticle*  CreateMotherParticle(const AliESDtrack *pdaughter, const AliESDtrack *ndaughter, Int_t pspec, Int_t nspec);//Mother Particle from KF
  
 
   //____________________________________________________________
   //Upper and lower limits for cut variables:
 
-  Float_t fUpDCA[kNDecays];                  // DCA, upper limit
-  Float_t fUpPointingAngle[kNDecays];        // pointing angle, upper limit
-  Float_t fUpOpenAngle[kNDecays];            // opening angle, upper limit
-  Float_t fDownOpenAngle[kNDecays];          // opening angle, lower limit
-  Float_t fUpPsiPair[kNDecays];              // psi angle, upper limit
-  Float_t fDownPsiPair[kNDecays];            // psi angle, lower limit
-  Double_t fUpChi2ndf[kNDecays];             // upper Chi2/NDF limit
-  Float_t fUpRadius[kNDecays];               // radius, upper limit
-  Float_t fDownRadius[kNDecays];             // radius, lower limit
-  Float_t fDownTPCPIDneg[AliPID::kSPECIES];  // TPC PID negatives, lower limit
-  Float_t fDownTPCPIDpos[AliPID::kSPECIES];  // TPC PID positives, lower limit
-  Float_t fDownComPIDneg[AliPID::kSPECIES];  // Combined PID negatives, lower limit
-  Float_t fDownComPIDpos[AliPID::kSPECIES];  // Combined PID positives, lower limit
-  Float_t fDownComPIDnegPart[AliPID::kSPECIES]; // Combined PID positive partner daughters (NOT the daughter track that would go into the reference data; here: pion daughters from Lambda decays; lower limit
-  Float_t fDownComPIDposPart[AliPID::kSPECIES]; // Combined PID positive partner daughters (NOT the daughter track that would go into the reference data; here: pion daughters from Lambda decays; lower limit
-  Double_t fUpInvMass[kNDecays][kNMomBins];  // invariant mass, upper limit
-  Double_t fDownInvMass[kNDecays];           // invariant mass, lower limit
-  
-  Double_t fChi2ndf[kNDecays];//Chi2/NDF from KF
-  
-  
-  Double_t fInvMass[kNDecays];  // invariant mass for different decay scenarios (conversions, K0s, Lambda->p+pi-, Lambda->p-pi+)
-  Int_t fQuality;              // track quality status for both V0 daughters; OnFly, TPCrefit, Kinks, TPC clusters
-  
-  Double_t fDetPID[kNDaughters][kNDetectors][AliPID::kSPECIES]; // PID provided by TPC, TOF and ITS
-  Double_t fComPID[kNDaughters][AliPID::kSPECIES];//Combined PID, momentarily from TPC and TOF only
-  
-  Float_t fDCA;  // Distance of closest approach of daughter tracks
-  Float_t fPointingAngle;// = TMath::ACos(esdv0->GetV0CosineOfPointingAngle()); // Cosine of pointing angle
-  Float_t fOpenAngle;  // opening angle between daughters
-  Float_t fPsiPair; // /Angle between daughter momentum plane and plane perpendicular to magnetic field
-  
-  Bool_t fArmenteros[kNDecays];// Array for the Armenteros yes/no decision for all decays
-  Double_t fMagField; //magnetic field strength
-  Float_t fRadius; //distance of decay/conversion from primary vertex in x-y plane
-  Float_t fV0Momentum; //V0 mother's momentum
-
-  Int_t       fNindex; //indices of positive and negative daughter track
-  Int_t       fPindex; //indices of positive and negative daughter track
-
-  Float_t fTPCdEdx[kNDaughters]; //Energy deposition in the TPC
-  
-  AliVEvent            *fInputEvent;    // Input Event
-  AliKFVertex          *fPrimaryVertex; // primary vertex
-  
-  AliESDtrack *fTrackP; //!positive daughter
-  AliESDtrack *fTrackN; //!negative daughter
-  
-  
-  ClassDef(AliTRDv0Info, 1) // extracted V0 MC information
+  Float_t         fUpDCA[kNDecays];                  // DCA, upper limit
+  Float_t         fUpPointingAngle[kNDecays];        // pointing angle, upper limit
+  Float_t         fUpOpenAngle[kNDecays];            // opening angle, upper limit
+  Float_t         fDownOpenAngle[kNDecays];          // opening angle, lower limit
+  Float_t         fUpPsiPair[kNDecays];              // psi angle, upper limit
+  Float_t         fDownPsiPair[kNDecays];            // psi angle, lower limit
+  Double_t        fUpChi2ndf[kNDecays];              // upper Chi2/NDF limit
+  Float_t         fUpRadius[kNDecays];               // radius, upper limit
+  Float_t         fDownRadius[kNDecays];             // radius, lower limit
+  Float_t         fDownTPCPIDneg[AliPID::kSPECIES];  // TPC PID negatives, lower limit
+  Float_t         fDownTPCPIDpos[AliPID::kSPECIES];  // TPC PID positives, lower limit
+  Float_t         fDownComPIDneg[AliPID::kSPECIES];  // Combined PID negatives, lower limit
+  Float_t         fDownComPIDpos[AliPID::kSPECIES];  // Combined PID positives, lower limit
+  Float_t         fDownComPIDnegPart[AliPID::kSPECIES]; // Combined PID positive partner daughters (NOT the daughter track that would go into the reference data; here: pion daughters from Lambda decays; lower limit
+  Float_t         fDownComPIDposPart[AliPID::kSPECIES]; // Combined PID positive partner daughters (NOT the daughter track that would go into the reference data; here: pion daughters from Lambda decays; lower limit
+  Double_t        fUpInvMass[kNDecays][kNMomBins];   // invariant mass, upper limit
+  Double_t        fDownInvMass[kNDecays];            // invariant mass, lower limit
+  Double_t        fChi2ndf[kNDecays];                //Chi2/NDF from KF
+  Double_t        fInvMass[kNDecays];                // invariant mass for different decay scenarios (conversions, K0s, Lambda->p+pi-, Lambda->p-pi+)
+  Int_t           fQuality;                          // track quality status for both V0 daughters; OnFly, TPCrefit, Kinks, TPC clusters
+  
+  Double_t        fDetPID[kNDaughters][kNDetectors][AliPID::kSPECIES]; // PID provided by TPC, TOF and ITS
+  Double_t        fComPID[kNDaughters][AliPID::kSPECIES];//Combined PID, momentarily from TPC and TOF only
+  
+  Float_t         fDCA;                              // Distance of closest approach of daughter tracks
+  Float_t         fPointingAngle;                    // = TMath::ACos(esdv0->GetV0CosineOfPointingAngle()); // Cosine of pointing angle
+  Float_t         fOpenAngle;                        // opening angle between daughters
+  Float_t         fPsiPair;                          // /Angle between daughter momentum plane and plane perpendicular to magnetic field
+  
+  Bool_t          fArmenteros[kNDecays];             // Array for the Armenteros yes/no decision for all decays
+  Double_t        fMagField;                         //magnetic field strength
+  Float_t         fRadius;                           //distance of decay/conversion from primary vertex in x-y plane
+  Float_t         fV0Momentum;                       //V0 mother's momentum
+
+  Int_t           fNindex;                           //indices of positive and negative daughter track
+  Int_t           fPindex;                           //indices of positive and negative daughter track
+
+  Float_t         fTPCdEdx[kNDaughters];             //Energy deposition in the TPC
+  AliVEvent*      fInputEvent;                       // Input Event
+  AliKFVertex*    fPrimaryVertex;                    // primary vertex
+  AliESDtrack*    fTrackP;                           //!positive daughter
+  AliESDtrack*    fTrackN;                           //!negative daughter
+  
+  ClassDef(AliTRDv0Info, 1)                          // extracted V0 MC information
 };
 
 
index 293c99c..473c9d1 100644 (file)
@@ -202,7 +202,7 @@ void processESD(TNamed *otask, const Char_t *filename)
   }
   esd->Terminate(NULL);
 
-  if(summary) esd->MakeSummary();
+  if(summary) esd->MakeSummaryFromCF(0, "", kFALSE, kFALSE);
   else{
     for(Int_t ipic(0); ipic<esd->GetNRefFigures(); ipic++){
       c->Clear();
index 0bd47ca..65d11b1 100644 (file)
@@ -2,6 +2,8 @@
 #include "TSystem.h"
 #include "TROOT.h"
 #include "TFile.h"
+#include "TBranch.h"
+#include "TIterator.h"
 #include "TTree.h"
 #include "TH1.h"
 #include "TF1.h"
@@ -350,12 +352,21 @@ void makeTrendingDB(const Char_t *fl)
              *resMail[] = {"M.Fasel@gsi.de", "A.Bercuci@gsi.de"};
   const char *notName[] = {"Julian Book", "Hans Beck", "Ionut Arsene", "Raphaelle Bailache", "Christoph Blume"},
              *notMail[] = {"jbook@ikf.uni-frankfurt.de", "hbeck@ikf.uni-frankfurt.de", "I.C.Arsene@gsi.de", "R.Bailhache@gsi.de", "blume@ikf.uni-frankfurt.de"};
-  for(Int_t jnt(0); jnt<nt; jnt++) printf("%3d %s %s\n", jnt, tvn[jnt][0], tvn[jnt][1]);
+  Int_t ires(0);
+  for(Int_t jnt(0); jnt<nt; jnt++){
+    //printf("%3d %s %s\n", jnt, tvn[jnt][0], tvn[jnt][1]);
+    if(!strstr(tvn[jnt][0], "TRDresolution")) ires=jnt;
+  }
+  ires++;
 
   TFile *fDB = TFile::Open("TRD.TrendDB.root", "RECREATE");
   TTree *tDB = new TTree("trend", "Reference Trend Values");
-  Double_t val[nt];
+  Double_t val[nt+500];
   for(Int_t it(0); it<nt; it++) tDB->Branch(tvn[it][0], &val[it], Form("%s/D", tvn[it][0]));
+  for(Int_t it(ires), jt(nt); it<nt; it++, jt++){
+    TString stn("TRDresolution_MC"); stn+=&tvn[it][0][14];
+    tDB->Branch(stn.Data(), &val[jt], Form("%s/D", stn.Data()));
+  }
   gROOT->cd();
 
   AliTRDtrendValue *tv(NULL);
@@ -378,6 +389,21 @@ void makeTrendingDB(const Char_t *fl)
       }
       val[it] = tv->GetVal();
     }
+    for(Int_t it(ires), jt(nt); it<nt; it++, jt++){
+      val[jt] = -999;
+      TString stn("TRDresolution_MC"); stn+=&tvn[it][0][14];
+      if(!(tv = (AliTRDtrendValue*)gFile->Get(stn.Data()))) {
+        //Warning("makeTrendingDB()", "Missing %s from %s", stn.Data(), sfp.Data());
+        nmiss++;
+        continue;
+      }
+      if((strstr(stn.Data(), "QS") || strstr(stn.Data(), "YS")) && TMath::Abs(tv->GetVal()) < 1.e-5){
+        //Info("makeTrendingDB()", "Found bad value for %s[%f] in %s", stn.Data(), tv->GetVal(), sfp.Data());
+        nbads++;
+        continue;
+      }
+      val[jt] = tv->GetVal();
+    }
     Warning("makeTrendingDB()", "%s :: Missing[%d] Bads[%d]", sfp.Data(), nmiss, nbads);
     gFile->Close();
     tDB->Fill();
@@ -402,8 +428,10 @@ void makeTrendingDB(const Char_t *fl)
   AliTRDtrendingManager *tm = AliTRDtrendingManager::Instance();
   TCanvas *c = new TCanvas("c", "Trend Distrib.", 10, 10, 500, 500);
   Int_t ntr=tDB->GetEntries();
-  for(Int_t it(0); it<nt; it++){
-    tDB->Draw(tvn[it][0], "", "goff");
+  TIterator *ib = tDB->GetListOfBranches()->MakeIterator();
+  TBranch *b(NULL); Int_t it(-1);
+  while((b=(TBranch*)ib->Next())){
+    tDB->Draw(b->GetName(), "", "goff"); it++;
     Double_t *v = tDB->GetV1(), xmin(100.), xmax(-100);
     Int_t ntr0(0);
     for(Int_t ir=0; ir<ntr; ir++){
@@ -412,35 +440,35 @@ void makeTrendingDB(const Char_t *fl)
       if(v[ir]<xmin) xmin = v[ir];
       if(v[ir]>xmax) xmax = v[ir];
     }
+    Double_t m(0.), s(0.);
     if(ntr0<10){
-      Warning("makeTrendingDB", "Couldn't create entry %s. Too few values %d", tvn[it][0], ntr0);
-      continue;
-    }
-    if((h =(TH1F*)gROOT->FindObject("hp"))){delete h; h = NULL;}
-    h = new TH1F("hp", Form(";%s;entries", tvn[it][0]), 25, 0.5*(3*xmin-xmax), 0.5*(3*xmax - xmin));
-    tDB->Draw(Form("%s>>hp", tvn[it][0]), Form("%s>-100", tvn[it][0]));
-    if(h->Integral() < 1) continue;
-    f.SetParameter(0, h->Integral());
-    f.SetParameter(1, h->GetMean());
-    f.SetParameter(2, h->GetRMS());
-    h->Fit(&f, "WQ");
-    c->Modified(); c->Update(); c->SaveAs(Form("Fit_%s.gif", tvn[it][0]));
+      Warning("makeTrendingDB", "%s :: Couldn't create reference value out of %d entries.", b->GetName(), ntr0);
+    } else {
+      if((h =(TH1F*)gROOT->FindObject("hp"))){delete h; h = NULL;}
+      h = new TH1F("hp", Form("%s;%s;entries", it<nt?tvn[it][1]:Form("MC %s", tvn[it-nt+ires][1]), b->GetName()), 25, 0.5*(3*xmin-xmax), 0.5*(3*xmax - xmin));
+      tDB->Draw(Form("%s>>hp", b->GetName()), Form("%s>-100", b->GetName()));
+      if(h->Integral() < 1) continue;
+      f.SetParameter(0, h->Integral());
+      f.SetParameter(1, h->GetMean());
+      f.SetParameter(2, h->GetRMS());
+      h->Fit(&f, "WQ");
+      c->Modified(); c->Update(); c->SaveAs(Form("Fit_%s.gif", b->GetName()));
 
-    // write trending value to manager
-    Info("makeTrendingDB", "%s [%f - %f] %f[%f]", tvn[it][0], xmin, xmax, f.GetParameter(1), f.GetParameter(2));
-    Double_t m(0.), s(0.);
-/*    if(strstr(tvn[it][0], "TrkInYS")) {
-      m=0.4; s=0.06;
-    } else if(strstr(tvn[it][0], "TrkInY")) {
-      m=0.; s=0.1;*/
-/*    } else if(strstr(tvn[it][0], "TrkInPh")) {
-      m=0.; s=0.35;*/
-/*    } else if(strstr(tvn[it][0], "TrkInQ") || strstr(tvn[it][0], "TrkInQS")) {
-      m=-2.; s=0.2;*/
-//    } else {
-      m=f.GetParameter(1); s=h->GetRMS()/*f.GetParameter(2)*/;
-//    }
-    tm->AddValue(tvn[it][0], m, s, tvn[it][1], res[it>13], notifiable);
+      // write trending value to manager
+      Info("makeTrendingDB", "%s :: %f+-%f [%f - %f]", b->GetName(), f.GetParameter(1), f.GetParameter(2), xmin, xmax);
+  /*    if(strstr(tvn[it][0], "TrkInYS")) {
+        m=0.4; s=0.06;
+      } else if(strstr(tvn[it][0], "TrkInY")) {
+        m=0.; s=0.1;*/
+  /*    } else if(strstr(tvn[it][0], "TrkInPh")) {
+        m=0.; s=0.35;*/
+  /*    } else if(strstr(tvn[it][0], "TrkInQ") || strstr(tvn[it][0], "TrkInQS")) {
+        m=-2.; s=0.2;*/
+  //    } else {
+        m=f.GetParameter(1); s=h->GetRMS()/*f.GetParameter(2)*/;
+  //    }
+    }
+    tm->AddValue(b->GetName(), m, s, it<nt?tvn[it][1]:Form("MC %s", tvn[it-nt+ires][1]), res[it>13], notifiable);
   }
   tm->Terminate();