new task introduced by Alex Wilk (calculation of reference data for NN
authorabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 17 Sep 2008 10:07:30 +0000 (10:07 +0000)
committerabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 17 Sep 2008 10:07:30 +0000 (10:07 +0000)
PID)
extended functionality for displaying the results

17 files changed:
TRD/Cal/AliTRDCalPIDNN.cxx
TRD/Cal/AliTRDCalPIDNN.h
TRD/TRDqaRecLinkDef.h
TRD/libTRDqaRec.pkg
TRD/qaRec/AliTRDcheckDetector.cxx
TRD/qaRec/AliTRDcheckDetector.h
TRD/qaRec/AliTRDpidChecker.cxx
TRD/qaRec/AliTRDpidChecker.h
TRD/qaRec/AliTRDpidRefMaker.cxx [new file with mode: 0644]
TRD/qaRec/AliTRDpidRefMaker.h [new file with mode: 0644]
TRD/qaRec/AliTRDrecoTask.cxx
TRD/qaRec/AliTRDrecoTask.h
TRD/qaRec/AliTRDtrackingResolution.cxx
TRD/qaRec/AliTRDtrackingResolution.h
TRD/qaRec/makeResults.C
TRD/qaRec/run.C
TRD/qaRec/run.h

index 7732040..abbe395 100644 (file)
@@ -148,9 +148,6 @@ Double_t AliTRDCalPIDNN::GetProbability(Int_t spec, Float_t mom, Float_t *dedx
   // layer in a given layer (iplane)
   //
 
-  const Int_t kMLPscale  = 16000; // scaling of the MLP input to be smaller than 1
-
-
   if (spec < 0 || spec >= AliPID::kSPECIES) return 0.;
 
   // find the interval in momentum and track segment length which applies for this data
@@ -162,21 +159,21 @@ Double_t AliTRDCalPIDNN::GetProbability(Int_t spec, Float_t mom, Float_t *dedx
 
   TMultiLayerPerceptron *nn = 0x0;
   if(!(nn = (TMultiLayerPerceptron *) fModel->At(GetModelID(imom-1, spec, iplane/*, ilength*/)))){
-    //if(!(nn = (TMultiLayerPerceptron*)fModel->At(GetModelID(imom-1, spec, iplane/*, ilength*/)))){
     AliInfo(Form("Looking for mom(%f) plane(%d)", mom-1, iplane));
     AliError(Form("NN id %d not found in DB.", GetModelID(imom-1, spec, iplane)));
     return 0.;
   }
 
   Double_t ddedx[AliTRDtrack::kNMLPslice];
+
   for (int inode=0; inode<AliTRDtrack::kNMLPslice; inode++) {
-    ddedx[inode] = (((Double_t) dedx[inode]/kMLPscale)*3)          // Bug fix! Needs new reference data or different calculation of dedx!!!!
+    ddedx[inode] = (((Double_t) dedx[inode]/kMLPscale)*6)          // Bug fix! Needs new reference data or different calculation of dedx!!!!
                  / (AliTRDcalibDB::Instance()->GetNumberOfTimeBins()/AliTRDtrack::kNMLPslice);
   }
+
   lNN1 = nn->Evaluate(spec, ddedx);
   
   if(!(nn = (TMultiLayerPerceptron*)fModel->At(GetModelID(imom, spec, iplane/*, ilength*/)))){
-    //if(!(nn = (TMultiLayerPerceptron*)fModel->At(GetModelID(imom, spec, iplane/*, ilength*/)))){
     AliInfo(Form("Looking for mom(%f) plane(%d)", mom, iplane));
     AliError(Form("NN id %d not found in DB.", GetModelID(imom, spec, iplane)));
     return lNN1;
index 523cdf8..7646096 100644 (file)
 
 class AliTRDCalPIDNN : public AliTRDCalPID
 {
-
  public:
 
+  enum{
+    kMLPscale  = 16000            // scaling of the MLP input to be smaller than 1
+  };
+
   AliTRDCalPIDNN();
   AliTRDCalPIDNN(const Text_t *name, const Text_t *title);
   virtual  ~AliTRDCalPIDNN();
index a591c16..d0f6012 100644 (file)
 #pragma link C++ class  AliTRDtrackInfoGen+;
 #pragma link C++ class  AliTRDrecoTask+;
 #pragma link C++ class  AliTRDcheckDetector+;
-#pragma link C++ class  AliTRDpidChecker+;
-#pragma link C++ class  AliTRDcalibration+;
 #pragma link C++ class  AliTRDtrackingResolution+;
 #pragma link C++ class  AliTRDtrackingEfficiency+;
 #pragma link C++ class  AliTRDtrackingEfficiencyCombined+;
+#pragma link C++ class  AliTRDcalibration+;
+#pragma link C++ class  AliTRDpidChecker+;
+#pragma link C++ class  AliTRDpidRefMaker+;
 
 #endif
index cce8c4d..7b8dc84 100644 (file)
@@ -4,6 +4,7 @@ SRCS= qaRec/AliTRDtrackInfoGen.cxx \
       qaRec/AliTRDrecoTask.cxx \
       qaRec/AliTRDcheckDetector.cxx \
       qaRec/AliTRDpidChecker.cxx \
+      qaRec/AliTRDpidRefMaker.cxx \
       qaRec/AliTRDcalibration.cxx \
       qaRec/AliTRDtrackingResolution.cxx \
       qaRec/AliTRDtrackingEfficiency.cxx \
index c598adf..7f2712a 100644 (file)
@@ -232,7 +232,7 @@ Bool_t AliTRDcheckDetector::PostProcess(){
 }
 
 //_______________________________________________________
-void AliTRDcheckDetector::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last){
+void AliTRDcheckDetector::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t */*opt*/){
        //
        // Setting Reference Figures
        //
index eb08b19..46636fc 100644 (file)
@@ -37,7 +37,7 @@ public:
   virtual void Terminate(Option_t *);
   
   virtual Bool_t PostProcess();
-  virtual void  GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);
+  virtual void  GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);
   
 private:
   AliTRDcheckDetector(const AliTRDcheckDetector &);
index 43d423d..3aaf522 100644 (file)
@@ -359,7 +359,7 @@ void AliTRDpidChecker::Exec(Option_t *)
 }
 
 //________________________________________________________
-void AliTRDpidChecker::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last)
+void AliTRDpidChecker::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t */*opt*/)
 {
   switch(ifig){
   case 0:
index 3b4a5b3..d57290d 100644 (file)
@@ -25,21 +25,21 @@ class AliTRDpidChecker : public AliTRDrecoTask
 {
 
   enum{
-      kLQlikelihood    = 0                                           // place for 2-dim LQ electron likelihood distributions
-       ,kNNlikelihood = 1 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for NN electron likelihood distributions
-       ,kdEdx         = 2 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for the dE/dx spectra
-       ,kPH           = 3 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for pulse height spectra
-       ,kMomentum     = 4 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for the momentum distribution
-       ,kMomentumBin  = kMomentum +1                                // place for the momentum distribution
-       ,kGraphLQ      = kMomentumBin +1                             // place for the 2-dim LQ pion efficiencies
-       ,kGraphLQerr   = kGraphLQ +1                                 // place for the 2-dim LQ pion efficiency errors
-       ,kGraphNN      = kGraphLQerr +1                              // place for the NN pion efficiencies
-       ,kGraphNNerr   = kGraphNN +1                                 // place for the NN pion efficiency errors
+    kLQlikelihood    = 0                                           // place for 2-dim LQ electron likelihood distributions
+    ,kNNlikelihood = 1 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for NN electron likelihood distributions
+    ,kdEdx         = 2 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for the dE/dx spectra
+    ,kPH           = 3 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for pulse height spectra
+    ,kMomentum     = 4 * AliTRDCalPID::kNMom * AliPID::kSPECIES  // place for the momentum distribution
+    ,kMomentumBin  = kMomentum +1                                // place for the momentum distribution
+    ,kGraphLQ      = kMomentumBin +1                             // place for the 2-dim LQ pion efficiencies
+    ,kGraphLQerr   = kGraphLQ +1                                 // place for the 2-dim LQ pion efficiency errors
+    ,kGraphNN      = kGraphLQerr +1                              // place for the NN pion efficiencies
+    ,kGraphNNerr   = kGraphNN +1                                 // place for the NN pion efficiency errors
   };
 
   enum{
     kGraphStart = kGraphLQ
-      };
+  };
 
 public:
   AliTRDpidChecker();
@@ -47,7 +47,7 @@ public:
   
   void    CreateOutputObjects();
   void    Exec(Option_t *option);
-  void    GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);  
+  void    GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);  
   Bool_t  PostProcess();
   void    Terminate(Option_t *);
 
diff --git a/TRD/qaRec/AliTRDpidRefMaker.cxx b/TRD/qaRec/AliTRDpidRefMaker.cxx
new file mode 100644 (file)
index 0000000..9621cbc
--- /dev/null
@@ -0,0 +1,239 @@
+#include "TPDGCode.h"
+#include "TH1F.h"
+#include "TTreeStream.h"
+
+#include "AliPID.h"
+#include "AliESDEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliTrackReference.h"
+
+#include "AliAnalysisTask.h"
+
+#include "AliTRDtrackV1.h"
+#include "AliTRDReconstructor.h"
+#include "../Cal/AliTRDCalPID.h"
+#include "../Cal/AliTRDCalPIDNN.h"
+
+#include "AliTRDpidRefMaker.h"
+#include "AliTRDtrackInfo/AliTRDtrackInfo.h"
+
+// builds the reference tree for the training of neural networks
+
+
+ClassImp(AliTRDpidRefMaker)
+
+//________________________________________________________________________
+AliTRDpidRefMaker::AliTRDpidRefMaker() 
+  :AliTRDrecoTask("PIDR", "PID Reference Tree Maker")
+  ,fReconstructor(0x0)
+{
+  //
+  // Default constructor
+  //
+
+  fReconstructor = new AliTRDReconstructor();
+  fReconstructor->SetRecoParam(AliTRDrecoParam::GetLowFluxParam());
+}
+
+
+//________________________________________________________________________
+AliTRDpidRefMaker::~AliTRDpidRefMaker() 
+{
+  if(fReconstructor) delete fReconstructor;
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::CreateOutputObjects()
+{
+  // Create histograms
+  // Called once
+
+  OpenFile(0, "RECREATE");
+  fContainer = new TObjArray();
+
+  fContainer->AddAt(new TH1F("hPDG","hPDG",AliPID::kSPECIES,-0.5,5.5),0);
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::Exec(Option_t *) 
+{
+  // Main loop
+  // Called for each event
+
+  Int_t labelsacc[10000]; 
+  memset(labelsacc, 0, sizeof(Int_t) * 10000);
+  
+  struct tChamb{
+    Float_t Slide[AliTRDReconstructor::kNNslices];
+  };
+  tChamb Chamb[AliTRDCalPID::kNPlane];
+
+  Float_t *fdEdx;
+
+  Float_t mom;
+  ULong_t status;
+  Int_t nTRD = 0;
+//   Float_t fdEdx[AliTRDCalPID::kNPlane][AliTRDReconstructor::kNNslices];
+  Float_t v0pdg[AliPID::kSPECIES];
+
+  AliTRDtrackInfo     *track = 0x0;
+  AliTRDtrackV1    *TRDtrack = 0x0;
+  AliTrackReference     *ref = 0x0;
+  AliExternalTrackParam *esd = 0x0;
+
+  AliTRDseedV1 *TRDtracklet[AliTRDCalPID::kNPlane];
+  for(Int_t iChamb = 0; iChamb < AliTRDCalPID::kNPlane; iChamb++) TRDtracklet[iChamb] = 0x0;
+
+  //AliTRDcluster *TRDcluster = 0x0;
+
+  for(Int_t itrk=0; itrk<fTracks->GetEntriesFast(); itrk++){
+
+    // reset the pid information
+    for(Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++)
+      v0pdg[iPart] = 0.;
+
+    track = (AliTRDtrackInfo*)fTracks->UncheckedAt(itrk);
+    if(!track->HasESDtrack()) continue;
+    status = track->GetStatus();
+    if(!(status&AliESDtrack::kTPCout)) continue;
+
+    if(!(TRDtrack = track->GetTRDtrack())) continue; 
+    //&&(track->GetNumberOfClustersRefit()
+
+    // use only tracks that hit 6 chambers
+    if(!(TRDtrack->GetNumberOfTracklets() == AliTRDCalPID::kNPlane)) continue;
+     
+    ref = track->GetTrackRef(0);
+    esd = track->GetOuterParam();
+    mom = ref ? ref->P(): esd->P();
+
+    labelsacc[nTRD] = track->GetLabel();
+    nTRD++;
+      
+    // if no monte carlo data available -> use V0 information
+    if(!HasMCdata()){
+      GetV0info(TRDtrack,v0pdg);
+    }
+    // else use the MC info
+    else{
+      switch(track -> GetPDG()){
+      case kElectron:
+      case kPositron:
+        v0pdg[AliPID::kElectron] = 1.;
+        break;
+      case kMuonPlus:
+      case kMuonMinus:
+        v0pdg[AliPID::kMuon] = 1.;
+        break;
+      case kPiPlus:
+      case kPiMinus:
+        v0pdg[AliPID::kPion] = 1.;
+        break;
+      case kKPlus:
+      case kKMinus:
+        v0pdg[AliPID::kKaon] = 1.;
+        break;
+      case kProton:
+      case kProtonBar:
+        v0pdg[AliPID::kProton] = 1.;
+        break;
+      }
+    }
+
+
+    // set reconstructor
+    TRDtrack -> SetReconstructor(fReconstructor);
+    fReconstructor -> SetOption("nn");
+
+    // fill the dE/dx information
+    for(Int_t iChamb = 0; iChamb < AliTRDCalPID::kNPlane; iChamb++){
+      TRDtracklet[iChamb] = TRDtrack -> GetTracklet(iChamb);
+      fdEdx = TRDtracklet[iChamb] -> GetdEdx();
+      for(Int_t iSlide = 0; iSlide < AliTRDReconstructor::kNNslices; iSlide++)
+      Chamb[iChamb].Slide[iSlide] = fdEdx[iSlide]/AliTRDCalPIDNN::kMLPscale;
+    }
+    
+
+    // fill the debug streams
+    if(fDebugLevel>=2){
+      (*fDebugStream) << "TreeInfo"
+        << "isele="   << v0pdg[0]
+        << "ismuo="   << v0pdg[1]
+        << "ispio="   << v0pdg[2]
+        << "iskao="   << v0pdg[3]
+        << "ispro="   << v0pdg[4]
+        << "\n";
+      for(Int_t iChamb = 0; iChamb < AliTRDCalPID::kNPlane; iChamb++){
+      (*fDebugStream) << Form("Chamb%d", iChamb)
+          << "Slide0=" << Chamb[iChamb].Slide[0]
+          << "Slide1=" << Chamb[iChamb].Slide[1]
+          << "Slide2=" << Chamb[iChamb].Slide[2]
+          << "Slide3=" << Chamb[iChamb].Slide[3]
+          << "Slide4=" << Chamb[iChamb].Slide[4]
+          << "Slide5=" << Chamb[iChamb].Slide[5]
+          << "Slide6=" << Chamb[iChamb].Slide[6]
+          << "Slide7=" << Chamb[iChamb].Slide[7]
+          << "\n";
+      }
+    }
+
+    for(Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++){
+      if(fDebugLevel>=4) Printf("PDG is %d %f", iPart, v0pdg[iPart]);
+    }
+  }
+
+  PostData(0, fContainer);
+}
+
+
+//________________________________________________________
+void AliTRDpidRefMaker::GetRefFigure(Int_t /*ifig*/, Int_t &/*first*/, Int_t &/*last*/, Option_t */*opt*/)
+{
+  
+}
+
+
+//________________________________________________________________________
+Bool_t AliTRDpidRefMaker::PostProcess()
+{
+  // Draw result to the screen
+  // Called once at the end of the query
+
+  return kTRUE; // testing protection
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::Terminate(Option_t *) 
+{
+  // Draw result to the screen
+  // Called once at the end of the query
+
+  fContainer = dynamic_cast<TObjArray*>(GetOutputData(0));
+  if (!fContainer) {
+    Printf("ERROR: list not available");
+    return;
+  }
+}
+
+
+//________________________________________________________________________
+void AliTRDpidRefMaker::GetV0info(AliTRDtrackV1 *TRDtrack, Float_t *v0pdg) 
+{
+
+  // !!!! PREMILMINARY FUNCTION !!!!
+  //
+  // this is the place for the V0 procedure
+  // as long as there is no implemented, just the probabilities
+  // of the TRDtrack is used!
+
+  TRDtrack -> SetReconstructor(fReconstructor);
+  fReconstructor -> SetOption("nn");
+  TRDtrack -> CookPID();
+  for(Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++){
+    v0pdg[iPart] = TRDtrack -> GetPID(iPart);
+    if(fDebugLevel>=4) Printf("PDG is (in V0info) %d %f", iPart, v0pdg[iPart]);
+  }
+}
diff --git a/TRD/qaRec/AliTRDpidRefMaker.h b/TRD/qaRec/AliTRDpidRefMaker.h
new file mode 100644 (file)
index 0000000..dc929a7
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef ALITRDPIDREFMAKER_H
+#define ALITRDPIDREFMAKER_H
+
+//////////////////////////////////////////////////////
+//
+// Task to build PID reference tree for the training
+// of neural networs for the TRD PID
+//
+// Author : Alex Wilk <wilka@uni-muenster.de>
+//
+///////////////////////////////////////////////////////
+
+#ifndef ALITRDRECOTASK_H
+#include "AliTRDrecoTask.h"
+#endif
+
+class AliTRDtrackV1;
+class AliTRDReconstructor;
+class AliTRDpidRefMaker : public AliTRDrecoTask
+{
+
+ public:
+  AliTRDpidRefMaker();
+  virtual ~AliTRDpidRefMaker();
+  
+  void    CreateOutputObjects();
+  void    Exec(Option_t *option);
+  void    GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);  
+  Bool_t  PostProcess();
+  void    Terminate(Option_t *);
+
+
+ private:
+  AliTRDpidRefMaker(const AliTRDpidRefMaker&);               // not implemented
+  AliTRDpidRefMaker& operator=(const AliTRDpidRefMaker&);    // not implemented
+
+  void GetV0info(AliTRDtrackV1 *TRDtrack, Float_t *v0pdg);           // get the v0 information
+
+  AliTRDReconstructor *fReconstructor;     //! reconstructor needed for recalculation the PID
+
+  ClassDef(AliTRDpidRefMaker, 1); // TRD reference  maker for NN
+};
+
+#endif
index 3b15979..4a5440d 100644 (file)
@@ -50,14 +50,14 @@ void AliTRDrecoTask::ConnectInputData(Option_t *)
 
 
 //_______________________________________________________
-void AliTRDrecoTask::GetRefFigure(Int_t /*ifig*/, Int_t &first, Int_t &last)
+void AliTRDrecoTask::GetRefFigure(Int_t /*ifig*/, Int_t &first, Int_t &last, Option_t */*opt*/)
 {
   AliWarning("Retrieving reference figures not implemented.");
   first = 0; last = 0;
 }
 
 //_______________________________________________________
-Bool_t AliTRDrecoTask::Load(Char_t *filename)
+Bool_t AliTRDrecoTask::Load(const Char_t *filename)
 {
   if(!TFile::Open(filename)) return kFALSE;
   TObjArray *o = (TObjArray*)gFile->Get(GetName());
index 36764cb..70ef1c1 100644 (file)
@@ -29,13 +29,13 @@ public:
 
   Int_t          GetDebugLevel() const { return fDebugLevel;}
   Int_t          GetNRefFigures() const { return fNRefFigures; } 
-  virtual void   GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);
+  virtual void   GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt="lp");
 
   Bool_t         HasFriends() const {return TestBit(kFriends);};
   Bool_t         HasMCdata() const {return TestBit(kMCdata);};
   Bool_t         HasPostProcess() const {return TestBit(kPostProcess);};
 
-  virtual Bool_t Load(Char_t *filename);
+  virtual Bool_t Load(const Char_t *filename);
   virtual Bool_t PostProcess();
   virtual void   SetDebugLevel(Int_t level);
   virtual void   SetFriends(Bool_t fr = kTRUE) {SetBit(kFriends, fr);}
index 537fddd..ce911c4 100644 (file)
@@ -159,7 +159,7 @@ void AliTRDtrackingResolution::CreateOutputObjects()
     h = new TH1I("h", "", 100, -40., 40.);
     h->GetXaxis()->SetTitle("#Phi [deg]");
     h->GetYaxis()->SetTitle("Tracklet Angular Resolution : #sigma/#mu [deg]");
-    h->GetYaxis()->SetRangeUser(-.05, 1.);
+    h->GetYaxis()->SetRangeUser(-.05, .2);
     fContainer->AddAt(h, jgraph++);
 
     g = new TGraphErrors(h2->GetNbinsX());
@@ -341,7 +341,7 @@ void AliTRDtrackingResolution::Exec(Option_t *)
 }
 
 //________________________________________________________
-void AliTRDtrackingResolution::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last)
+void AliTRDtrackingResolution::GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t */*opt*/)
 {
   switch(ifig){
   case 0:
index b6076d2..123902f 100644 (file)
@@ -44,7 +44,7 @@ public:
   
   void    CreateOutputObjects();
   void    Exec(Option_t *);
-  void    GetRefFigure(Int_t ifig, Int_t &first, Int_t &last);  
+  void    GetRefFigure(Int_t ifig, Int_t &first, Int_t &last, Option_t *opt);  
   void    SetRecoParam(AliTRDrecoParam *r);
   Bool_t  PostProcess();
   void    Terminate(Option_t *);
index 962352a..c10cac9 100644 (file)
@@ -1,7 +1,8 @@
 #if ! defined (__CINT__) || defined (__MAKECINT__)
+#include "TError.h"
 #include <TClass.h>
 #include <TFileMerger.h>
-#include <TPad.h>
+#include <TCanvas.h>
 #include <TH1.h>
 #include <TGraph.h>
 #include <TObjArray.h>
 #include <TString.h>
 #include <TROOT.h>
 #include <TSystem.h>
+#include <TStyle.h>
 
 #include "qaRec/AliTRDrecoTask.h"
 
-// #include <string>
-// #include <iostream>
-// #include <cstdio>
-
 #endif
 
 #include "run.h"
@@ -26,18 +24,14 @@ Char_t *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libTRDqaRec.so", "libP
 void makeResults(Char_t* dir=0x0, Char_t *tasks = "ALL")
 {
        // Load Libraries in interactive mode
-//#ifndef __CINT__
   Int_t nlibs = static_cast<Int_t>(sizeof(libs)/sizeof(Char_t *));
   for(Int_t ilib=0; ilib<nlibs; ilib++){
     if(!gSystem->Load(libs[ilib])) continue;
     printf("Failed to load %s.\n", libs[ilib]);
     return;
   }
-  //gSystem->Setenv("PYTHONPATH", "$ROOTSYS/lib:$PYTHONPATH");
-//#endif
 
 
-  //printf("dir[%s] tasks[%s]\n", dir, tasks);
   gStyle->SetOptStat(0);
   Bool_t mc      = kTRUE;
   Bool_t friends = kTRUE;
@@ -52,30 +46,23 @@ void makeResults(Char_t* dir=0x0, Char_t *tasks = "ALL")
     if(s.CompareTo("ALL") == 0){
       for(Int_t itask = 1; itask < fknTasks; itask++) SETBIT(fSteerTask, itask);
       continue;
-    } else if(s.CompareTo("EFF") == 0){
-      SETBIT(fSteerTask, kTrackingEfficiency);
-      continue;
-    } else if(s.CompareTo("EFFC") == 0){
-      SETBIT(fSteerTask, kTrackingCombinedEfficiency);
-      continue;
-    } else if(s.CompareTo("RES") == 0){
-      SETBIT(fSteerTask, kTrackingResolution);
-      continue;
-    } else if(s.CompareTo("CAL" ) == 0){
-      SETBIT(fSteerTask, kCalibration);
-      continue;
-    } else if(s.CompareTo("PID" ) == 0){
-      SETBIT(fSteerTask, kPIDChecker);
-      continue;
-    } else if(s.CompareTo("DET" ) == 0){
-       SETBIT(fSteerTask, kCheckDetector);
-       continue;
-    } else{
-      std::cout << "E-makeResults.C: Task "<< s.Data() << " %s not implemented (yet).\n";
-      continue;
+    } else if(s.CompareTo("NOFR") == 0){ 
+      friends = kFALSE;
+    } else if(s.CompareTo("NOMC") == 0){ 
+      mc = kFALSE;
+    } else { 
+      Bool_t foundOpt = kFALSE;  
+      for(Int_t itask = 1; itask < fknTasks; itask++){
+        if(s.CompareTo(fTaskOpt[itask]) != 0) continue;
+        SETBIT(fSteerTask, itask);
+        foundOpt = kTRUE;
+        break;
+      }
+      if(!foundOpt) Info("makeResults.C", Form("Task %s not implemented (yet).", s.Data()));
     }
   }
 
+
   // catch the list of files using the ROOT Python Interface
   TPython *pyshell = new TPython();
   pyshell->Exec("import commands");
@@ -93,7 +80,7 @@ void makeResults(Char_t* dir=0x0, Char_t *tasks = "ALL")
 
     ctask = new TClass(fTaskClass[itask]);
     task = (AliTRDrecoTask*)ctask->New();
-    task->SetDebugLevel(2);
+    task->SetDebugLevel(0);
     task->SetMCdata(mc);
     task->SetFriends(friends);
     printf("\t%s [%s]\n", task->GetTitle(), task->GetName());
@@ -134,9 +121,9 @@ void makeResults(Char_t* dir=0x0, Char_t *tasks = "ALL")
     task->PostProcess();
     for(Int_t ipic=0; ipic<task->GetNRefFigures(); ipic++){
       TCanvas *c = new TCanvas("c", "", 500, 500);
-      Int_t ifirst, ilast;
+      Int_t ifirst, ilast; Option_t *opt;
       TH1 *h = 0x0; TGraph *g = 0x0;
-      task->GetRefFigure(ipic, ifirst, ilast);
+      task->GetRefFigure(ipic, ifirst, ilast, opt);
       if(!(o = fContainer->At(ifirst))) continue;
       
       if(o->InheritsFrom("TH1")){ 
index c8d02a6..1bc520a 100644 (file)
@@ -10,6 +10,7 @@
 //     "PID"  : TRD PID - pion efficiency 
 //     "PIDR" : TRD PID - reference data
 //     "DET"  : Basic TRD Detector checks
+//     "NOFR" : Data set does not have AliESDfriends.root 
 //     "NOMC" : Data set does not have Monte Carlo Informations (real data), so all tasks which rely
 //              on MC information are switched off
 //
@@ -53,6 +54,7 @@
 #include "TRD/qaRec/AliTRDtrackingResolution.h"
 #include "TRD/qaRec/AliTRDcalibration.h"
 #include "TRD/qaRec/AliTRDpidChecker.h"
+#include "TRD/qaRec/AliTRDpidRefMaker.h"
 #include "TRD/qaRec/AliTRDcheckDetector.h"
 #endif
 
@@ -77,42 +79,31 @@ void run(const Char_t *files=0x0, Char_t *tasks="ALL", Int_t nmax=-1)
   gSystem->Load("libANALYSIS.so");
   gSystem->Load("libTRDqaRec.so");
   
-  Int_t fSteerTask = 0; 
   Bool_t fHasMCdata = kTRUE;
+  Bool_t fHasFriends = kTRUE;
   TObjArray *tasksArray = TString(tasks).Tokenize(" ");
+
+  Int_t fSteerTask = 0; SETBIT(fSteerTask, kInfoGen);
   for(Int_t isel = 0; isel < tasksArray->GetEntriesFast(); isel++){
     TString s = (dynamic_cast<TObjString *>(tasksArray->UncheckedAt(isel)))->String();
     if(s.CompareTo("ALL") == 0){
-      for(Int_t itask = 0; itask < fknTasks; itask++) SETBIT(fSteerTask, itask);
-      continue;
-    } else if(s.CompareTo("EFF") == 0){
-      SETBIT(fSteerTask, kTrackingEfficiency);
-      continue;
-    } else if(s.CompareTo("EFFC") == 0){
-      SETBIT(fSteerTask, kTrackingCombinedEfficiency);
-      continue;
-    } else if(s.CompareTo("RES") == 0){
-      SETBIT(fSteerTask, kTrackingResolution);
+      for(Int_t itask = 1; itask < fknTasks; itask++) SETBIT(fSteerTask, itask);
       continue;
-    } else if(s.CompareTo("CAL" ) == 0){
-      SETBIT(fSteerTask, kCalibration);
-      continue;
-    } else if(s.CompareTo("PID" ) == 0){
-      SETBIT(fSteerTask, kPIDChecker);
-      continue;
-    } else if(s.CompareTo("DET" ) == 0){
-       SETBIT(fSteerTask, kCheckDetector);
-       continue;
-    } else if(s.CompareTo("NOMC") == 0){
-       CLEARBIT(fSteerTask, kTrackingEfficiency);
-       CLEARBIT(fSteerTask, kTrackingCombinedEfficiency);
+    } else if(s.CompareTo("NOFR") == 0){ 
+      fHasFriends = kFALSE;
+    } else if(s.CompareTo("NOMC") == 0){ 
       fHasMCdata = kFALSE;
-    } else{
-      Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
-      continue;
+    } else { 
+      Bool_t foundOpt = kFALSE;  
+      for(Int_t itask = 1; itask < fknTasks; itask++){
+        if(s.CompareTo(fTaskOpt[itask]) != 0) continue;
+        SETBIT(fSteerTask, itask);
+        foundOpt = kTRUE;
+        break;
+      }
+      if(!foundOpt) Info("run.C", Form("Task %s not implemented (yet).", s.Data()));
     }
   }
-
   // define task list pointers;
   AliTRDrecoTask *taskPtr[fknTasks], *task = 0x0;
   memset(taskPtr, 0, fknTasks*sizeof(AliAnalysisTask*));
@@ -152,30 +143,41 @@ void run(const Char_t *files=0x0, Char_t *tasks="ALL", Int_t nmax=-1)
   mgr->ConnectInput( task, 0, cinput1);
   mgr->ConnectOutput(task, 0, coutput1);
 
+  //____________________________________________
+  // TRD detector checker
+       if(TESTBIT(fSteerTask, kCheckDetector)){
+    mgr->AddTask(task = new AliTRDcheckDetector());
+    taskPtr[(Int_t)kCheckDetector] = task;
+    task->SetDebugLevel(0);
+    task->SetMCdata(fHasMCdata);
+    
+    // Create containers for input/output
+    mgr->ConnectInput( task, 0, coutput1);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
+  }
+
   //____________________________________________
   // TRD barrel tracking efficiency
-  if(TESTBIT(fSteerTask, kTrackingEfficiency)){
+  if(fHasMCdata && TESTBIT(fSteerTask, kTrackingEfficiency)){
     mgr->AddTask(task = new AliTRDtrackingEfficiency());
     taskPtr[(Int_t)kTrackingEfficiency] = task;
     task->SetDebugLevel(0);
 
     //Create containers for input/output
-    AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
     mgr->ConnectInput( task, 0, coutput1);
-    mgr->ConnectOutput(task, 0, coutput2);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
   }
 
   //____________________________________________
   // TRD combined tracking efficiency
-  if(TESTBIT(fSteerTask, kTrackingCombinedEfficiency)){
+  if(fHasMCdata && TESTBIT(fSteerTask, kTrackingCombinedEfficiency)){
     mgr->AddTask(task = new AliTRDtrackingEfficiencyCombined());
     taskPtr[(Int_t)kTrackingCombinedEfficiency] = task;
     task->SetDebugLevel(0);
 
     // Create containers for input/output
-    AliAnalysisDataContainer *coutput3 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
     mgr->ConnectInput( task, 0, coutput1);
-    mgr->ConnectOutput(task, 0, coutput3);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
   }
 
   //____________________________________________
@@ -188,9 +190,8 @@ void run(const Char_t *files=0x0, Char_t *tasks="ALL", Int_t nmax=-1)
     task->SetDebugLevel(2);
     
     // Create containers for input/output
-    AliAnalysisDataContainer *coutput4 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
     mgr->ConnectInput( task, 0, coutput1);
-    mgr->ConnectOutput(task, 0, coutput4);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
   }
 
   //____________________________________________
@@ -204,9 +205,8 @@ void run(const Char_t *files=0x0, Char_t *tasks="ALL", Int_t nmax=-1)
     task->SetDebugLevel(0);
 
     // Create containers for input/output
-    AliAnalysisDataContainer *coutput5 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
     mgr->ConnectInput(task, 0, coutput1);
-    mgr->ConnectOutput(task, 0, coutput5);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
   }
   
   //____________________________________________
@@ -218,25 +218,25 @@ void run(const Char_t *files=0x0, Char_t *tasks="ALL", Int_t nmax=-1)
     task->SetMCdata(fHasMCdata);
     
     // Create containers for input/output
-    AliAnalysisDataContainer *coutput6 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
     mgr->ConnectInput( task, 0, coutput1);
-    mgr->ConnectOutput(task, 0, coutput6);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
   }
 
+
   //____________________________________________
-  // TRD detector checker
-       if(TESTBIT(fSteerTask, kCheckDetector)){
-    mgr->AddTask(task = new AliTRDcheckDetector());
-    taskPtr[(Int_t)kCheckDetector] = task;
+  // TRD pid checker
+  if(TESTBIT(fSteerTask, kPIDRefMaker)){
+    mgr->AddTask(task = new AliTRDpidRefMaker());
+    taskPtr[(Int_t)kPIDRefMaker] = task;
     task->SetDebugLevel(0);
     task->SetMCdata(fHasMCdata);
     
     // Create containers for input/output
-    AliAnalysisDataContainer *coutput7 = mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName()));
     mgr->ConnectInput( task, 0, coutput1);
-    mgr->ConnectOutput(task, 0, coutput7);
+    mgr->ConnectOutput(task, 0, mgr->CreateContainer(task->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("TRD.Task%s.root", task->GetName())));
   }
 
+
   if (!mgr->InitAnalysis()) return;
   printf("\n\tRUNNING TRAIN FOR TASKS:\n");
   for(Int_t itask = 1; itask < fknTasks; itask++){
index 1e9821d..fd763ee 100644 (file)
@@ -6,25 +6,40 @@
 #define TESTBIT(n,i)  ((Bool_t)(((n) & BIT(i)) != 0))
 #define CLEARBIT(n,i) ((n) &= ~BIT(i))
 
-const Int_t fknTasks = 7;
+const Int_t fknTasks = 8;
 enum AliTRDrecoTasks{
-  kInfoGen = 0
-  ,kTrackingEfficiency = 1
-  ,kTrackingCombinedEfficiency = 2
-  ,kTrackingResolution = 3
-  ,kCalibration = 4
-  ,kPIDChecker = 5
-  ,kCheckDetector = 6
+   kInfoGen = 0
+  ,kCheckDetector = 1
+  ,kTrackingEfficiency = 2
+  ,kTrackingCombinedEfficiency = 3
+  ,kTrackingResolution = 4
+  ,kCalibration = 5
+  ,kPIDChecker = 6
+  ,kPIDRefMaker = 7
 };
 
 Char_t *fTaskClass[fknTasks] = {
   "AliTRDtrackInfoGen"
+  ,"AliTRDcheckDetector"
   ,"AliTRDtrackingEfficiency"
   ,"AliTRDtrackingEfficiencyCombined"
   ,"AliTRDtrackingResolution"
   ,"AliTRDcalibration"
   ,"AliTRDpidChecker"
-  ,"AliTRDcheckDetector"
+  ,"AliTRDpidRefMaker"
+};
+
+Char_t *fTaskOpt[fknTasks+2] = {
+  "ALL"
+  ,"DET"
+  ,"EFF"
+  ,"EFFC"
+  ,"RES"
+  ,"CAL"
+  ,"PID"
+  ,"PIDR"
+  ,"NOFR"
+  ,"NOMC"
 };
 
 #endif