Fixing coding conventions
authormrodrigu <mrodrigu@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Jul 2010 13:40:55 +0000 (13:40 +0000)
committermrodrigu <mrodrigu@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Jul 2010 13:40:55 +0000 (13:40 +0000)
ACORDE/macros/AnalysisMacros/Local/AliAnalysisTaskAcorde.cxx
ACORDE/macros/AnalysisMacros/Local/AliAnalysisTaskAcorde.h

index 7263527..635260c 100644 (file)
@@ -8,7 +8,7 @@
 //     Also it is implemented a simple matching between tracks
 //     to look for the extrapolation of them to ACORDE modules
 //
-//     Create some histograms and one tree with the information
+//     Create some fHistograms and one tree with the information
 //     of the matching tracks
 //
 //  Author: Mario Rodríguez Cahuantzi
@@ -48,26 +48,26 @@ ClassImp(AliAnalysisTaskAcorde)
 AliAnalysisTaskAcorde::AliAnalysisTaskAcorde(const char *name) 
   : AliAnalysisTask(name, ""), 
        fESD(0),
-       cosmicTree(0),
-       nTracks(0),
-       nMatchTracks(0),
-       minTPCclusters(30),
-       minTrackDist(1000.),
-       minCutDir(0.95),
-       xAco(0),
-       yAco(0),
-       zAco(0),
-       trigger(0),
-       ActiveTriggerDetector(0),
-       nSingleTracks(0),
-       nMatchedTracks(0),
-       histo(0),
-       ntracks(0),
-       acordeHitsAll(0),
-       acordeMultiAll(0),
-       acordeHitsTPC(0),
-       acordeMultiTPC(0),
-       nTracksMatched(0),
+       fCosmicTree(0),
+       fnTracks(0),
+       fNMatchTracks(0),
+       fkMinTPCclusters(30),
+       fkMinTrackDist(1000.),
+       fkMinCutDir(0.95),
+       fXAco(0),
+       fYAco(0),
+       fZAco(0),
+       fTrigger(0),
+       fActiveTriggerDetector(0),
+       fNSingleTracks(0),
+       fNMatchedTracks(0),
+       fHisto(0),
+       fNTracks(0),
+       fAcordeHitsAll(0),
+       fAcordeMultiAll(0),
+       fAcordeHitsTPC(0),
+       fAcordeMultiTPC(0),
+       fNTracksMatched(0),
        fTracksToAcorde(0)
 
 {
@@ -84,8 +84,8 @@ AliAnalysisTaskAcorde::~AliAnalysisTaskAcorde()
        // destructor --> avoid watchdog mails?
        
        delete fESD;
-       delete histo;
-       delete cosmicTree;
+       delete fHisto;
+       delete fCosmicTree;
 }
 //________________________________________________________________________
 void AliAnalysisTaskAcorde::ConnectInputData(Option_t *) 
@@ -112,36 +112,36 @@ void AliAnalysisTaskAcorde::ConnectInputData(Option_t *)
 void AliAnalysisTaskAcorde::CreateOutputObjects()
 {
 
-       // creates one TList with some histograms
+       // creates one TList with some fHistograms
 
-       histo = new TList();
+       fHisto = new TList();
 
-       nTracksMatched = new TH1F("nTracksMatched","nTracksMatched from matching algorithm implemented",300,1,300);
-       ntracks = new TH1F("ntracks","nTracks distribution",500,1,500);
-       acordeHitsAll = new TH1F("acordeHitsAll","Hits of ACORDE from ESD",60,-0.5,59.5);
-       acordeHitsTPC = new TH1F("acordeHitsAllTPC","Hits of ACORDE from ESD (if ntracks>0)",61,0,60);
-       acordeMultiAll = new TH1F("acordeMultiAll","Multiplicity of ACORDE modules from ESD",60,-0.5,59.5);
-       acordeMultiTPC = new TH1F("acordeMultiAllTPC","Multiplicity of ACORDE modules from ESD (id ntracks>0)",61,0,60);
+       fNTracksMatched = new TH1F("fNTracksMatched","fNTracksMatched from matching algorithm implemented",300,1,300);
+       fNTracks = new TH1F("fNTracks","fnTracks distribution",500,1,500);
+       fAcordeHitsAll = new TH1F("fAcordeHitsAll","Hits of ACORDE from ESD",60,-0.5,59.5);
+       fAcordeHitsTPC = new TH1F("fAcordeHitsAllTPC","Hits of ACORDE from ESD (if fNTracks>0)",61,0,60);
+       fAcordeMultiAll = new TH1F("fAcordeMultiAll","Multiplicity of ACORDE modules from ESD",60,-0.5,59.5);
+       fAcordeMultiTPC = new TH1F("fAcordeMultiAllTPC","Multiplicity of ACORDE modules from ESD (id fNTracks>0)",61,0,60);
        fTracksToAcorde = new TH2F("fTracksToAcorde","Extrapolated tracks to ACORDE x:z",1200,-600,600,1200,-600,600);
 
-       histo->Add(nTracksMatched);
-       histo->Add(ntracks);
-       histo->Add(acordeHitsAll);
-       histo->Add(acordeHitsTPC);
-       histo->Add(acordeMultiAll);
-       histo->Add(acordeMultiTPC);
-       histo->Add(fTracksToAcorde);
+       fHisto->Add(fNTracksMatched);
+       fHisto->Add(fNTracks);
+       fHisto->Add(fAcordeHitsAll);
+       fHisto->Add(fAcordeHitsTPC);
+       fHisto->Add(fAcordeMultiAll);
+       fHisto->Add(fAcordeMultiTPC);
+       fHisto->Add(fTracksToAcorde);
 
        // Create Tree branches
        // Called just once
 
-       cosmicTree = new TTree("cosmicTree","cosmicTreeMRC");
-       cosmicTree->Branch("nTracks",&nTracks,"nTracks/I");
-       cosmicTree->Branch("nMatchTracks",&nMatchTracks,"nMatchTracks/I");
-       cosmicTree->Branch("xAco",&xAco,"xAco/F");
-       cosmicTree->Branch("yAco",&yAco,"yAco/F");
-       cosmicTree->Branch("zAco",&zAco,"zAco/F");
-       cosmicTree->Branch("trigger",&trigger,"trigger/I");
+       fCosmicTree = new TTree("fCosmicTree","fCosmicTreeMRC");
+       fCosmicTree->Branch("fnTracks",&fnTracks,"fnTracks/I");
+       fCosmicTree->Branch("fNMatchTracks",&fNMatchTracks,"fNMatchTracks/I");
+       fCosmicTree->Branch("fXAco",&fXAco,"fXAco/F");
+       fCosmicTree->Branch("fYAco",&fYAco,"fYAco/F");
+       fCosmicTree->Branch("fZAco",&fZAco,"fZAco/F");
+       fCosmicTree->Branch("fTrigger",&fTrigger,"fTrigger/I");
 
 }
 
@@ -174,96 +174,96 @@ void AliAnalysisTaskAcorde::Exec(Option_t *)
        {
                if (acordeESD->GetHitChannel(imod)) 
                {
-                       acordeHitsAll->Fill(imod);
+                       fAcordeHitsAll->Fill(imod);
                        contMulti++;
                }
 
-       }acordeMultiAll->Fill(contMulti);
+       }fAcordeMultiAll->Fill(contMulti);
 
        for(Int_t imod=0;imod<60;imod++)
        {
                if (acordeESD->GetHitChannel(imod))
                {
-                       acordeHitsTPC->Fill(imod);
+                       fAcordeHitsTPC->Fill(imod);
                        contMultiTPC++;
                }
-       }acordeMultiTPC->Fill(contMultiTPC);
+       }fAcordeMultiTPC->Fill(contMultiTPC);
 
 
-       // Assingment of the type of Trigger to cosmicTree
+       // Assingment of the type of Trigger to fCosmicTree
 
-       ActiveTriggerDetector = fESD->GetFiredTriggerClasses();
+       fActiveTriggerDetector = fESD->GetFiredTriggerClasses();
 
-       if (ActiveTriggerDetector.Contains("C0SCO")) trigger=0;
-       if (ActiveTriggerDetector.Contains("C0SH2")) trigger=1;
-       if (ActiveTriggerDetector.Contains("C0AMU")) trigger=2;
-       if (ActiveTriggerDetector.Contains("C0LSR")) trigger=3;
-       if (ActiveTriggerDetector.Contains("C0SCO1")) trigger=4;
-       if (ActiveTriggerDetector.Contains("C0OBE")) trigger=5;
-       if (ActiveTriggerDetector.Contains("C0PCO")) trigger=6;
-       if (ActiveTriggerDetector.Contains("C0OB3")) trigger=7;
-       if (ActiveTriggerDetector.Contains("C0OCP")) trigger=8;
-       if (ActiveTriggerDetector.Contains("C0ASL")) trigger=9;
+       if (fActiveTriggerDetector.Contains("C0SCO")) fTrigger=0;
+       if (fActiveTriggerDetector.Contains("C0SH2")) fTrigger=1;
+       if (fActiveTriggerDetector.Contains("C0AMU")) fTrigger=2;
+       if (fActiveTriggerDetector.Contains("C0LSR")) fTrigger=3;
+       if (fActiveTriggerDetector.Contains("C0SCO1")) fTrigger=4;
+       if (fActiveTriggerDetector.Contains("C0OBE")) fTrigger=5;
+       if (fActiveTriggerDetector.Contains("C0PCO")) fTrigger=6;
+       if (fActiveTriggerDetector.Contains("C0OB3")) fTrigger=7;
+       if (fActiveTriggerDetector.Contains("C0OCP")) fTrigger=8;
+       if (fActiveTriggerDetector.Contains("C0ASL")) fTrigger=9;
        
 
        // Begins the matching analysis between tracks
 
-       nTracks = fESD->GetNumberOfTracks();
-       if (nTracks<=0) return;
-       ntracks->Fill(nTracks);
+       fnTracks = fESD->GetNumberOfTracks();
+       if (fnTracks<=0) return;
+       fNTracks->Fill(fnTracks);
 
-       fPair = new TArrayI(nTracks);
-       nSingleTracks=0;
-       nMatchedTracks=0;
+       fPair = new TArrayI(fnTracks);
+       fNSingleTracks=0;
+       fNMatchedTracks=0;
        Int_t muons = 0;
        TFile *curfile = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
-       for (Int_t iTrack=0; iTrack<nTracks; iTrack++)
+       for (Int_t iTrack=0; iTrack<fnTracks; iTrack++)
        {
 
-               // Special case: nTracks == 1
-               if (nTracks ==1)
+               // Special case: fnTracks == 1
+               if (fnTracks ==1)
                {
                        AliESDtrack *singleTrack = fESD->GetTrack(iTrack);
                        if (!singleTrack || !singleTrack->GetOuterParam() || !singleTrack->GetInnerParam()) continue;
-                       if (singleTrack->GetTPCNcls()<minTPCclusters) continue;
+                       if (singleTrack->GetTPCNcls()<fkMinTPCclusters) continue;
                        Float_t vertX = singleTrack->Xv();
                        Float_t vertZ = singleTrack->Zv();
                        if (TMath::Abs(vertX)>165 || TMath::Abs(vertZ)>245) continue; // far away from the VERTEX
                        if (singleTrack->E()< 1) continue; // less than 1 GeV 
                        if (singleTrack->P()< 1) continue; // less than 1 GeV 
-                       nMatchTracks=0;
-                       nSingleTracks = nTracks;
+                       fNMatchTracks=0;
+                       fNSingleTracks = fnTracks;
                        muons = 1;
 
-               } // nTracks ==1
-               else if (nTracks>1) // nTracks > 1
+               } // fnTracks ==1
+               else if (fnTracks>1) // fnTracks > 1
                {
 
                        AliESDtrack *track0 = fESD->GetTrack(iTrack);
                        (*fPair)[iTrack]=-1;
                        if (!track0 || !track0->GetOuterParam() || !track0->GetInnerParam()) continue;
 
-                       Double_t track0_dir[3];
-                       track0->GetDirection(track0_dir);
-                       Float_t minDist = minTrackDist; 
+                       Double_t trackdir0[3];
+                       track0->GetDirection(trackdir0);
+                       Float_t minDist = fkMinTrackDist;       
 
                        const AliExternalTrackParam * trackIn = track0->GetInnerParam();
                        const AliExternalTrackParam * trackOut = track0->GetOuterParam();
 
                        if (!trackIn || !trackOut) continue;
-                       if (nTracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue; // Filter TPC-Laser
+                       if (fnTracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue; // Filter TPC-Laser
 
-                       if (track0->GetTPCNcls()<minTPCclusters) continue;
+                       if (track0->GetTPCNcls()<fkMinTPCclusters) continue;
 
-                       for (Int_t jTrack=iTrack; jTrack<nTracks; ++jTrack)
+                       for (Int_t jTrack=iTrack; jTrack<fnTracks; ++jTrack)
                        {
                                AliESDtrack *track1 = fESD->GetTrack(jTrack);
                                if (!track1 || !track1->GetOuterParam() || !track1->GetInnerParam()) continue;
-                               Double_t track1_dir[3];
-                               track1->GetDirection(track1_dir);
-                               if (track1->GetTPCNcls()<minTPCclusters) continue;
-                               Float_t direction = track0_dir[0]*track1_dir[0] + track0_dir[1]*track1_dir[1] + track0_dir[2]*track1_dir[2];
-                               if (TMath::Abs(direction)<minCutDir) continue; // direction vector product
+                               Double_t trackdir1[3];
+                               track1->GetDirection(trackdir1);
+                               if (track1->GetTPCNcls()<fkMinTPCclusters) continue;
+                               Float_t direction = trackdir0[0]*trackdir1[0] + trackdir0[1]*trackdir1[1] + trackdir0[2]*trackdir1[2];
+                               if (TMath::Abs(direction)<fkMinCutDir) continue; // direction vector product
                                Float_t dvertex0[3];
                                Float_t dvertex1[3];
 
@@ -299,7 +299,7 @@ void AliAnalysisTaskAcorde::Exec(Option_t *)
 
 
                        }       
-               } // nTracks > 1
+               } // fnTracks > 1
        
 
        } // Loop over all the tracks
@@ -309,46 +309,46 @@ void AliAnalysisTaskAcorde::Exec(Option_t *)
 
        // Matching tracks
        
-       for (Int_t itrack=0;itrack<nTracks;itrack++)
+       for (Int_t itrack=0;itrack<fnTracks;itrack++)
        {
-               AliESDtrack *UpTrack = 0;
-               AliESDtrack *DownTrack = 0;
+               AliESDtrack *upTrack = 0;
+               AliESDtrack *downTrack = 0;
 
-               AliESDtrack *Track0 = fESD->GetTrack(itrack);
-               if (!Track0 || !Track0->GetOuterParam() || !Track0->GetInnerParam() ) continue;
+               AliESDtrack *track0 = fESD->GetTrack(itrack);
+               if (!track0 || !track0->GetOuterParam() || !track0->GetInnerParam() ) continue;
 
                Double_t mxyz[3];
-               Track0->GetOuterParam()->GetXYZ(mxyz);
+               track0->GetOuterParam()->GetXYZ(mxyz);
                
-               UpTrack = Track0;
+               upTrack = track0;
        
 
                if ((*fPair)[itrack]>0)
                {
-                       AliESDtrack *Track1 = fESD->GetTrack((*fPair)[itrack]);
-                       if (!Track1 || !Track1->GetOuterParam() || !Track1->GetInnerParam()) continue;
+                       AliESDtrack *track1 = fESD->GetTrack((*fPair)[itrack]);
+                       if (!track1 || !track1->GetOuterParam() || !track1->GetInnerParam()) continue;
                        Float_t dvertex0[3];
                        Float_t dvertex1[3];
 
-                       dvertex0[0] = Track0->Xv();
-                       dvertex0[1] = Track0->Yv();
-                       dvertex0[2] = Track0->Zv();
+                       dvertex0[0] = track0->Xv();
+                       dvertex0[1] = track0->Yv();
+                       dvertex0[2] = track0->Zv();
 
-                       dvertex1[0] = Track1->Xv();
-                       dvertex1[1] = Track1->Yv();
-                       dvertex1[2] = Track1->Zv();
+                       dvertex1[0] = track1->Xv();
+                       dvertex1[1] = track1->Yv();
+                       dvertex1[2] = track1->Zv();
 
                        Float_t distTracks = TMath::Sqrt((dvertex0[0]-dvertex1[0])*(dvertex0[0]-dvertex1[0]) + (dvertex0[1]-dvertex1[1])*(dvertex0[1]-dvertex1[1]) + (dvertex0[2]-dvertex1[2])*(dvertex0[2]-dvertex1[2]) );
                        if (distTracks>2.5) continue;
 
-                       if (Track1->GetOuterParam())
+                       if (track1->GetOuterParam())
                        {
                                Double_t nxyz[3];
-                               Track1->GetOuterParam()->GetXYZ(nxyz);
+                               track1->GetOuterParam()->GetXYZ(nxyz);
                                if (nxyz[1]>mxyz[1])
                                {
-                                       UpTrack = Track1;
-                               }else DownTrack = Track1;
+                                       upTrack = track1;
+                               }else downTrack = track1;
                        }
 
 
@@ -357,12 +357,12 @@ void AliAnalysisTaskAcorde::Exec(Option_t *)
 
 
                        const Double_t kRL3 = 510; // radious of L3 magnet
-                       const Double_t kxAcorde = 850.; // radios of "ACORDE" above the magnet
+                       const Double_t kfXAcorde = 850.; // radios of "ACORDE" above the magnet
 
                        Double_t agxyz[3];
                        
 
-                       AliExternalTrackParam *upper = (AliExternalTrackParam *)(UpTrack->GetOuterParam()->Clone());
+                       AliExternalTrackParam *upper = (AliExternalTrackParam *)(upTrack->GetOuterParam()->Clone());
 
                        Bool_t isOk = upper->PropagateTo(kRL3,fESD->GetMagneticField());
                        upper->GetXYZ(agxyz);
@@ -379,33 +379,33 @@ void AliAnalysisTaskAcorde::Exec(Option_t *)
 
                        if (isOk) upper->Rotate(alpha);
 
-                       if (isOk) isOk = upper->PropagateTo(kxAcorde,0);
+                       if (isOk) isOk = upper->PropagateTo(kfXAcorde,0);
 
                        TVectorD rgxyz(3);
                        AliExternalTrackParam *param = (AliExternalTrackParam *)upper;
                        param->GetXYZ(rgxyz.GetMatrixArray());
-                       xAco = rgxyz[0];
-                       yAco = rgxyz[1];
-                       zAco = rgxyz[2];
-                       fTracksToAcorde->Fill(xAco,zAco);
+                       fXAco = rgxyz[0];
+                       fYAco = rgxyz[1];
+                       fZAco = rgxyz[2];
+                       fTracksToAcorde->Fill(fXAco,fZAco);
                        // Count how many tracks have been matched
-                       nMatchedTracks++;
-               } else nSingleTracks++;
+                       fNMatchedTracks++;
+               } else fNSingleTracks++;
        }
 
-       if ( (nMatchedTracks+nSingleTracks) <= nTracks ) muons=nMatchedTracks+nSingleTracks;
-       nTracksMatched->Fill(muons);
+       if ( (fNMatchedTracks+fNSingleTracks) <= fnTracks ) muons=fNMatchedTracks+fNSingleTracks;
+       fNTracksMatched->Fill(muons);
 
-       nMatchTracks = nSingleTracks + nMatchedTracks;
+       fNMatchTracks = fNSingleTracks + fNMatchedTracks;
        
        // Fills the tree
 
-       cosmicTree->Fill();
+       fCosmicTree->Fill();
        
        // Post output data.
 
-       PostData(0,cosmicTree);
-       PostData(1,histo);
+       PostData(0,fCosmicTree);
+       PostData(1,fHisto);
 }      
 
 //________________________________________________________________________
@@ -419,12 +419,12 @@ void AliAnalysisTaskAcorde::Terminate(Option_t *)
 
         c1->Divide(2,2);
        c1->cd(1);
-       acordeHitsAll->Draw();
+       fAcordeHitsAll->Draw();
        c1->cd(2)->SetLogy();
-       acordeMultiAll->Draw();
+       fAcordeMultiAll->Draw();
        c1->cd(3)->SetLogy();
-       //nTracksMatched->Draw();
-       ntracks->Draw();
+       //fNTracksMatched->Draw();
+       fNTracks->Draw();
        c1->cd(4);
        fTracksToAcorde->Draw();
        
index de1686b..fe12137 100644 (file)
@@ -8,7 +8,7 @@
 //     Also it is implemented a simple matching between tracks\r
 //     to look for the extrapolation of them to ACORDE modules\r
 //\r
-//     Create some histograms and one tree with the information\r
+//     Create some fHistograms and one tree with the information\r
 //     of the matching tracks\r
 //\r
 //  Author: Mario Rodríguez Cahuantzi\r
@@ -20,8 +20,8 @@
 //\r
 /////////////////////////////////////////////////////////////////////////////\r
 \r
-#ifndef AliAnalysisTaskAcorde_cxx\r
-#define AliAnalysisTaskAcorde_cxx\r
+#ifndef ALIANALYSISTASKACORDE_H\r
+#define ALIANALYSISTASKACORDE_H\r
 \r
 class TH2F;\r
 class TH1F;\r
@@ -36,7 +36,7 @@ class AliAnalysisTaskAcorde : public AliAnalysisTask {
   virtual ~AliAnalysisTaskAcorde();            //! Destructor fo task\r
   \r
   virtual void   ConnectInputData(Option_t *);         //! Connects input data to class analysis\r
-  virtual void   CreateOutputObjects();        //! Creates output object (cosmicTree)\r
+  virtual void   CreateOutputObjects();        //! Creates output object (fCosmicTree)\r
   virtual void   Exec(Option_t *option);       //! Execution class\r
   virtual void   Terminate(Option_t *);        //! Terminate class \r
 \r
@@ -45,34 +45,34 @@ class AliAnalysisTaskAcorde : public AliAnalysisTask {
 \r
   AliESDEvent *fESD;                   //! ESD object\r
   TArrayI      *fPair;                 //! Pair track connected (up & down)\r
-  TTree *cosmicTree;                   //! TTree with some information of matched tracks\r
-  Int_t nTracks;                       //! # of recontructed tracks\r
-  Int_t nMatchTracks;                  //! # of matched tracks\r
+  TTree *fCosmicTree;                  //! TTree with some information of matched tracks\r
+  Int_t fnTracks;                      //! # of recontructed tracks\r
+  Int_t fNMatchTracks;                 //! # of matched tracks\r
 \r
 \r
   // Cut definitions\r
 \r
-  const Int_t minTPCclusters;          //! cut in clusters\r
-  const Float_t minTrackDist;          //! cut in distance\r
-  const Float_t minCutDir;             //! minimum cut\r
+  const Int_t fkMinTPCclusters;                //! cut in clusters\r
+  const Float_t fkMinTrackDist;                //! cut in distance\r
+  const Float_t fkMinCutDir;           //! minimum cut\r
 \r
-  Float_t xAco;                                //! x-coordinate of extrapolated track to ACORDE\r
-  Float_t yAco;                                //! y-coordinate of extrapolated track to ACORDE\r
-  Float_t zAco;                                //! z-coordinate of extrapolated track to ACORDE\r
-  Int_t trigger;                       //! trigger label\r
-  TString ActiveTriggerDetector;       //! detector string     \r
+  Float_t fXAco;                               //! x-coordinate of extrapolated track to ACORDE\r
+  Float_t fYAco;                               //! y-coordinate of extrapolated track to ACORDE\r
+  Float_t fZAco;                               //! z-coordinate of extrapolated track to ACORDE\r
+  Int_t fTrigger;                      //! fTrigger label\r
+  TString fActiveTriggerDetector;      //! detector string     \r
 \r
-  Int_t nSingleTracks;                 //! no. of single track\r
-  Int_t nMatchedTracks;                        //! no. of matched track\r
+  Int_t fNSingleTracks;                        //! no. of single track\r
+  Int_t fNMatchedTracks;                       //! no. of matched track\r
   \r
 \r
-  TList *histo;                                //! list of histograms\r
-  TH1F *acordeHitsAll;                 //! hits of acorde\r
-  TH1F *acordeMultiAll;                        //! multi. of acorde modules\r
-  TH1F *acordeHitsTPC;                 //! hits of acorde (if track)\r
-  TH1F *acordeMultiTPC;                        //! multi. of acorde modules (if track)\r
-  TH1F *nTracksMatched;                        //! matched tracks\r
-  TH1F *ntracks;                       //! no. of tracks\r
+  TList *fHisto;                               //! list of fHistograms\r
+  TH1F *fAcordeHitsAll;                        //! hits of acorde\r
+  TH1F *fAcordeMultiAll;                       //! multi. of acorde modules\r
+  TH1F *fAcordeHitsTPC;                        //! hits of acorde (if track)\r
+  TH1F *fAcordeMultiTPC;                       //! multi. of acorde modules (if track)\r
+  TH1F *fNTracksMatched;                       //! matched tracks\r
+  TH1F *fNTracks;                      //! no. of tracks\r
   TH2F *fTracksToAcorde;               //! tracks extrapolated to acorde.\r
 \r
   AliAnalysisTaskAcorde(const AliAnalysisTaskAcorde&); // not implemented\r