grrrr
authorsnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Mar 2007 13:58:16 +0000 (13:58 +0000)
committersnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Mar 2007 13:58:16 +0000 (13:58 +0000)
16 files changed:
PWG2/FLOW/AliFlowAnalyser.cxx
PWG2/FLOW/AliFlowAnalyser.h
PWG2/FLOW/AliFlowConstants.h
PWG2/FLOW/AliFlowEvent.cxx
PWG2/FLOW/AliFlowEvent.h
PWG2/FLOW/AliFlowMaker.cxx
PWG2/FLOW/AliFlowMaker.h
PWG2/FLOW/AliFlowSelection.cxx
PWG2/FLOW/AliFlowSelection.h
PWG2/FLOW/AliFlowTrack.cxx
PWG2/FLOW/AliFlowTrack.h
PWG2/FLOW/AliFlowV0.cxx
PWG2/FLOW/AliFlowV0.h
PWG2/FLOW/AliFlowWeighter.h
PWG2/FLOW/AliSelectorFoF.cxx
PWG2/FLOW/AliSelectorFoF.h

index 57331bb55aac32fc6e25c019c9149dd2b4098937..4a1028f6408c1c8f8fe3784c3f34ec69bc8356d3 100644 (file)
@@ -55,7 +55,7 @@
 #include <TChain.h>
 #include <TString.h>
 #include <TObject.h>
-#include <TObjArray.h>
+#include <TClonesArray.h>
 #include <TOrdCollection.h>
 #include <TParticle.h>
 #include <TParticlePDG.h>
@@ -147,6 +147,8 @@ Bool_t AliFlowAnalyser::Init()
  fFlowV0     = 0 ;
  fFlowTracks = 0 ;
  fFlowV0s    = 0 ;
+ fSelParts = 0 ;
+ fSelV0s   = 0 ;
  for(Int_t ii=0;ii<3;ii++) { fVertex[ii] = 0 ; }
 
  // Check for Reading weights: if weight file is not there, wgt arrays are not used (phiwgt & bayesian)
@@ -1981,7 +1983,7 @@ Bool_t AliFlowAnalyser::Analyse(AliFlowEvent* flowEvent)
  else 
  {
   cout << " * 0 . Event " << fEventNumber << " (event ID = " << fFlowEvent->EventID() << ") discarded . " << endl ; 
-  delete fFlowEvent  ; fFlowEvent = 0 ; 
+  // delete fFlowEvent  ; fFlowEvent = 0 ; 
   return kFALSE ;
  }
  fEventNumber++ ;
@@ -2130,7 +2132,7 @@ void AliFlowAnalyser::FillEventHistograms(AliFlowEvent* fFlowEvent)
  return ;
 }
 //-----------------------------------------------------------------------
-void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks) 
+void AliFlowAnalyser::FillParticleHistograms(TClonesArray* fFlowTracks) 
 {
  // fills tracks histograms
 
@@ -2157,10 +2159,14 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
  float muonMinusN     = 0. ;
  float muonPlusN      = 0. ;
 
+ fSelParts = 0 ;
+ fSelV0s   = 0 ;
  for(fTrackNumber=0;fTrackNumber<fNumberOfTracks;fTrackNumber++) 
  {
-  fFlowTrack = (AliFlowTrack*)fFlowTracks->At(fTrackNumber) ;
-  //cout << "Track n. " << fTrackNumber << endl ; fFlowTrack->Dump() ; 
+  //fFlowTrack = (AliFlowTrack*)fFlowTracks->At(fTrackNumber) ;
+  
+  fFlowTrack = (AliFlowTrack*)(fFlowTracks->AddrAt(fTrackNumber)) ;
+  //cout << "Track n. " << fTrackNumber << endl ; // fFlowTrack->Dump() ; 
   
   bool constrainable = fFlowTrack->IsConstrainable() ;
   // int label = fFlowTrack->Label() ;                         
@@ -2211,41 +2217,35 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
   fHistTransDca->Fill(dcaSigned);
   fHistChi2->Fill(chi2);
   
-  // - here ITS   (chi2 & nHits)
-  fHistChi2ITS->Fill(chi2ITS);
-  if (fitPtsITS>0)
-    fHistChi2normITS->Fill(chi2ITS/((float)fitPtsITS));
-  fHistFitPtsITS->Fill((float)fitPtsITS);
-  fHistMaxPtsITS->Fill((float)maxPtsITS);
-
   // - here TPC   (chi2 & nHits)
   fHistChi2TPC->Fill(chi2TPC);
-  if (fitPtsTPC>0)
-    fHistChi2normTPC->Fill(chi2TPC/((float)fitPtsTPC));
+  if(fitPtsTPC>0) { fHistChi2normTPC->Fill(chi2TPC/((float)fitPtsTPC)) ; }
   fHistFitPtsTPC->Fill((float)fitPtsTPC);
   fHistMaxPtsTPC->Fill((float)maxPtsTPC);
-  if(maxPtsTPC>0)
-    fHistFitOverMaxTPC->Fill((float)(fitPtsTPC)/(float)maxPtsTPC);
+  if(maxPtsTPC>0) { fHistFitOverMaxTPC->Fill((float)(fitPtsTPC)/(float)maxPtsTPC) ; }
+
+  // - here ITS   (chi2 & nHits)
+  fHistChi2ITS->Fill(chi2ITS);
+  if(fitPtsITS>0) { fHistChi2normITS->Fill(chi2ITS/((float)fitPtsITS)) ; }
+  fHistFitPtsITS->Fill((float)fitPtsITS);
+  fHistMaxPtsITS->Fill((float)maxPtsITS);
 
-  // - here TRD  (chi2 & nHits)
+  // - here TRD   (chi2 & nHits)
   fHistChi2TRD->Fill(chi2TRD);
-  if (fitPtsTRD>0)
-    fHistChi2normTRD->Fill(chi2TRD/((float)fitPtsTRD));
+  if(fitPtsTRD>0) { fHistChi2normTRD->Fill(chi2TRD/((float)fitPtsTRD)) ; }
   fHistFitPtsTRD->Fill((float)fitPtsTRD);
   fHistMaxPtsTRD->Fill((float)maxPtsTRD);
 
   // - here TOF   (chi2 & nHits)
   fHistChi2TOF->Fill(chi2TOF);
-  if (fitPtsTOF>0)
-    fHistChi2normTOF->Fill(chi2TOF/((float)fitPtsTOF));
+  if(fitPtsTOF>0) { fHistChi2normTOF->Fill(chi2TOF/((float)fitPtsTOF)) ; }
   fHistFitPtsTOF->Fill((float)fitPtsTOF);
   fHistMaxPtsTOF->Fill((float)maxPtsTOF);
   
   // fit over max (all)
   int maxPts = maxPtsITS + maxPtsTPC + maxPtsTRD + maxPtsTOF ;
   int fitPts = fitPtsITS + fitPtsTPC + fitPtsTRD + fitPtsTOF ;
-  if(maxPts>0)
-    fHistFitOverMax->Fill((float)(fitPts)/(float)maxPts) ;
+  if(maxPts>0)    { fHistFitOverMax->Fill((float)(fitPts)/(float)maxPts) ; }
   
   // lenght
   fHistLenght->Fill(lenght) ;
@@ -2326,7 +2326,7 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
     fHistMeanTOFDeuteron->Fill(invMass, tof);
     fHistPidDeuteronPart->Fill(deuteron) ;
    }
-  } 
+  }
   else if(charge == -1) 
   {
    hMinusN++ ;
@@ -2430,6 +2430,8 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
   // fills selected part histograms
   if(fFlowSelect->SelectPart(fFlowTrack)) 
   {
+   fSelParts++ ;
+  
    if(strlen(fFlowSelect->PidPart()) != 0) 
    {
     float rapidity = fFlowTrack->Y();
@@ -2530,7 +2532,8 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
 
  // Multiplicity of particles correlated with the event planes
  corrMultN /= (float)(AliFlowConstants::kHars * AliFlowConstants::kSels) ; 
- fHistMultPart->Fill(corrMultN) ;
+ if(fSelParts == corrMultN) { fHistMultPart->Fill(corrMultN) ; } // crosscheck
+ else                              { fHistMultPart->Fill(-1) ; }
  // ...in one unit rapidity
  corrMultUnit /= (float)(AliFlowConstants::kHars * AliFlowConstants::kSels) ; 
  fHistMultPartUnit->Fill(corrMultUnit) ;
@@ -2760,16 +2763,19 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
  return corrMultN ;
 }
 //-----------------------------------------------------------------------
-void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
+void AliFlowAnalyser::FillV0Histograms(TClonesArray* fFlowV0s)
 {
  // v0s histograms
 
  cout << " V0s Loop . " << endl ;
 
int corrMultV0 = 0 ;
fSelV0s = 0 ;
  for(fV0Number=0;fV0Number<fNumberOfV0s;fV0Number++) 
  {
-  fFlowV0 = (AliFlowV0*)fFlowV0s->At(fV0Number) ;          
+  //fFlowV0 = (AliFlowV0*)fFlowV0s->At(fV0Number) ;      
+  
+  fFlowV0 = (AliFlowV0*)(fFlowV0s->AddrAt(fV0Number)) ;
+  // cout << " looping v0 n. " << fV0Number << " * " << fFlowV0 << endl ;  
 
   float mass = fFlowV0->Mass() ;                   
   float eta = fFlowV0->Eta() ;                     
@@ -2805,7 +2811,7 @@ void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
    bool inWin = fFlowSelect->SelectV0Part(fFlowV0) ;
    bool sx = fFlowSelect->SelectV0sxSide(fFlowV0) ;
    bool dx = fFlowSelect->SelectV0dxSide(fFlowV0) ;
-   corrMultV0++ ;
+   fSelV0s++ ;
 
    fHistV0YieldPart2D->Fill(eta, pt) ;
    if(inWin) 
@@ -2978,7 +2984,7 @@ void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
   //delete daughterPlus ; daughterPlus = 0 ;  
   //delete daughterMinus ; daughterMinus = 0 ;  
  }
- fHistV0MultPart->Fill(corrMultV0) ;
+ fHistV0MultPart->Fill(fSelV0s) ;
 
  return ;
 }
@@ -3059,6 +3065,11 @@ void AliFlowAnalyser::PrintEventQuantities() const
   cout << "            " ; 
  }
  cout << endl ;
+
+ cout << " N. of selected tracks - SelPart(AliFlowTrack*) = " << fSelParts << endl ;                                   //! n. of tracks selected for correlation analysis
+ cout << " N. of selected V0s    - SelPart(AliFlowV0*)    = " << fSelV0s << endl ;                                     //! n. of v0s selected for correlation analysis
+
+ cout << endl ;
 }
 //----------------------------------------------------------------------
 // ###
@@ -3453,7 +3464,7 @@ Double_t AliFlowAnalyser::ResEventPlaneK4(Double_t chi)
 
  return res ;
 }
-//-------------------------------------------------------------
+//-----------------------------------------------------------------------
 // ###
 //-----------------------------------------------------------------------
 
index d0da0e8c41684bc2e7799fdcceaf3bdb6bb0ba80..69861d200c1523b041460bbf86b1ae857eb1efd5 100644 (file)
@@ -15,7 +15,7 @@
 #ifndef ALIFLOWANALYSER_H
 #define ALIFLOWANALYSER_H
 
-// #include <TVector2.h>
+#include <TVector2.h>
 #include <TFile.h>
 #include "AliFlowConstants.h"
 
@@ -27,7 +27,8 @@ class TH3F;
 class TProfile;
 class TProfile2D;
 class TOrdCollection;
-class TVector2 ;
+
+class TClonesArray;
 
 class AliFlowTrack;
 class AliFlowV0;
@@ -96,8 +97,8 @@ public:
  // Internal methods to fill the histogram
   Bool_t   FillFromFlowEvent(AliFlowEvent* fFlowEvent) ;       // Fills internal variables and array from Flow Events
   void     FillEventHistograms(AliFlowEvent* fFlowEvent) ;     // Fills Events' histograms (from AliFlowEvent)
-  void     FillParticleHistograms(TObjArray* fFlowTracks) ;    // Fills Tracks' histograms (from AliFlowTrack)
-  void     FillV0Histograms(TObjArray* fFlowV0s) ;             // Fills V0s' histograms
+  void     FillParticleHistograms(TClonesArray* fFlowTracks) ;         // Fills Tracks' histograms (from AliFlowTrack)
+  void     FillV0Histograms(TClonesArray* fFlowV0s) ;          // Fills V0s' histograms
   Int_t    HarmonicsLoop(AliFlowTrack* fFlowTrack) ;           // Harmonics & Selections histograms (from AliFlowTracks)
   //void     FillLabels() ;                                    // fills an histogram of Labels (the ones from ESD) 
 
@@ -115,8 +116,9 @@ public:
 
  private:
 
-  //AliFlowAnalyser(const AliFlowAnalyser &flowAnal)           { flowAnal.fPhiBins ; } // Copy Constructor (dummy)
-  //AliFlowAnalyser &operator=(const AliFlowAnalyser &flowAnal) { return *this ; }     // Assignment Operator
+ // to make the code checker happy
+  AliFlowAnalyser(const AliFlowAnalyser &flowAnal) ;           // Copy Constructor (dummy)
+  AliFlowAnalyser &operator=(const AliFlowAnalyser &flowAnal) ; // Assignment Operator
 
  // Flags
   Bool_t          fTrackLoop ;                                 //! tracks main loop
@@ -146,14 +148,16 @@ public:
   Int_t           fNumberOfTracks ;                            //! total number of tracks in the current event
   Int_t           fNumberOfV0s ;                               //! total number of v0s in the current event
   Int_t            fPidId ;                                    //! Particle Id hypothesys of the track (0..4 for e,mu,pi,k,p)
+  Int_t            fSelParts ;                                 //! n. of tracks selected for correlation analysis
+  Int_t            fSelV0s ;                                   //! n. of v0s selected for correlation analysis
 
  // Internal pointers
   AliFlowEvent*     fFlowEvent ;                               //! pointer to AliFlowEvent
   AliFlowTrack*     fFlowTrack ;                               //! pointer to AliFlowTrack
   AliFlowV0*        fFlowV0 ;                                  //! pointer to AliFlowV0
   AliFlowSelection* fFlowSelect ;                              //! selection object
-  TObjArray*        fFlowTracks ;                              //! pointer to the TrackCollection
-  TObjArray*        fFlowV0s ;                                 //! pointer to the V0Collection
+  TClonesArray*     fFlowTracks ;                              //! pointer to the TrackCollection
+  TClonesArray*     fFlowV0s ;                                 //! pointer to the V0Collection
 
   Float_t           fVertex[3] ;                               //! Event's Vertex position 
 
@@ -169,8 +173,6 @@ public:
 
  // For bayesian weights
   Double_t fBayesianWgt[AliFlowConstants::kSels][AliFlowConstants::kPid] ;     //! Bayesian weights (expected particle abundance)
-
-#ifndef __CINT__
   TVector2 fQ[AliFlowConstants::kSels][AliFlowConstants::kHars];                       //! flow vector
   Float_t  fPsi[AliFlowConstants::kSels][AliFlowConstants::kHars];                     //! event plane angle
   UInt_t   fMult[AliFlowConstants::kSels][AliFlowConstants::kHars];                    //! multiplicity
@@ -180,7 +182,6 @@ public:
   UInt_t   fMultSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];        //! multiplicity subs
   Float_t  fRes[AliFlowConstants::kSels][AliFlowConstants::kHars];                     //! event plane resolution
   Float_t  fResErr[AliFlowConstants::kSels][AliFlowConstants::kHars];                  //! event plane resolution error
-#endif /*__CINT__*/
 
  // for Histograms
   TString           fLabel ;                                   //! label axis : rapidity or pseudorapidity
index 5ba3b31e1b70708d49685fe5ef79af270d267a89..2a0f978c0d980697da2600eb35c697411269623b 100644 (file)
 
 class AliFlowConstants {
 
+
  public:
 
+ // Enumerators
   enum {
     kHars        =   2,                                        // number of harmonics (>= 2)
     kSels        =   2,                                        // number of selections (for each harmonics) 
@@ -39,20 +41,59 @@ class AliFlowConstants {
     kPid         = 6                                           // total number of p.id. hypotesis
   };
 
-  typedef Double_t PhiWgt_t[kSels][kHars][kPhiBins];           // intermediate type to import weights from histograms' file 
+ // new type
+  typedef Double_t PhiWgt_t[kSels][kHars][kPhiBins];           // 3d_array type,used to import phi weights from histograms 
 
-  static Int_t   fgMClabel ;                                   // checking the simulation: pTrack->Label()<fMClabel = primary track 
-  static Bool_t  fgDebug ;                                     // for more cout statements (debugging purpose)
+//  // Get methods  (not working ...)
+//   Int_t   MClabel() const      { return fgMClabel ; }
+//   Bool_t  Debug() const        { return fgDebug ; } 
+//   Float_t MaxInt() const       { return fgMaxInt ; }          
+// 
+//   Float_t EtaMin() const       { return fgEtaMin ; }                 
+//   Float_t EtaMax() const       { return fgEtaMax ; }                 
+//   Float_t PtMin() const        { return fgPtMin ; }                
+//   Float_t PtMax() const        { return fgPtMax ; }                
+//   Float_t PtMaxPart() const    { return fgPtMaxPart ; }               
+//   Float_t PtWgtSaturation() const  { return fgPtWgtSaturation ; }         
+// 
+//   Float_t EtaMid() const       { return fgEtaMid ; }         
+//   Float_t EtaGood() const      { return fgEtaGood ; }                       
+// 
+//   Float_t  MaxMult() const     { return fgMaxMult ; }                       
+//   Int_t    Cent(Int_t i) const     { return (Int_t)(fgMaxMult * fgCentNorm[i]) ; }
+//   Int_t    Cent0(Int_t i) const        { return fgCent0[i] ; }
+//   Double_t Bayesian(Int_t i) const { return fgBayesian[i] ; }
+// 
+//   Float_t  ITSx() const                { return fgITSx ; }             
+//   Float_t  TPCx() const                { return fgTPCx ; }             
+//   Float_t  TRDx() const                { return fgTRDx ; }             
+//   Float_t  TOFx() const                { return fgTOFx ; }             
+// 
+//   Double_t MagneticField() const      { return fgMagneticField ; }        
+//   Double_t CenterOfMassEnergy() const { return fgCenterOfMassEnergy ; }  
+//   Short_t  BeamMassNumberEast() const { return fgBeamMassNumberEast ; }  
+//   Short_t  BeamMassNumberWest() const { return fgBeamMassNumberWest ; }  
+// 
+//  // Set methods
+//   void SetEtaGood(Float_t eta)                 { fgEtaGood = eta; }                 
+//   void SetMClabel(Int_t mc)            { fgMClabel = mc ; }
+//   void SetDebug(Int_t db)              { fgDebug = db ; } 
+//   void SetMaxMult(Float_t mult)        { fgMaxMult = mult ; }               
+//   void SetCent0(Int_t i, Int_t mult)       { fgCent0[i] = mult ; }
+//   void SetBayesian(Int_t i, Double_t mult) { fgBayesian[i] = mult ; }
+// 
+// 
+//  private:
 
  // Histograms limits
-  static Float_t fgEtaMin ;                                    // eta lower limit for FlowAnalysis histograms
-  static Float_t fgEtaMax ;                                    // eta upper limit for FlowAnalysis histograms
-  static Float_t fgPtMin ;                                     // pT lower limit for FlowAnalysis histograms
-  static Float_t fgPtMax ;                                     // pT upper limit for yield histograms
-  static Float_t fgPtMaxPart ;                                 // pT upper limit for flow histograms
-  static Float_t fgPtWgtSaturation ;                           // flow(pT) saturation value
-  static Float_t fgEtaMinTpcOnly ;                             // eta lower limit of the full TPC acceptance (unused)
-  static Float_t fgEtaMaxTpcOnly ;                             // eta upper limit of the full TPC acceptance (unused)
+  static Float_t  fgEtaMin ;                                   // eta lower limit for FlowAnalysis histograms
+  static Float_t  fgEtaMax ;                                   // eta upper limit for FlowAnalysis histograms
+  static Float_t  fgPtMin ;                                    // pT lower limit for FlowAnalysis histograms
+  static Float_t  fgPtMax ;                                    // pT upper limit for yield histograms
+  static Float_t  fgPtMaxPart ;                                // pT upper limit for flow histograms
+  static Float_t  fgPtWgtSaturation ;                          // flow(pT) saturation value
+  static Float_t  fgEtaMinTpcOnly ;                            // eta lower limit of the full TPC acceptance (-0.9)
+  static Float_t  fgEtaMaxTpcOnly ;                            // eta upper limit of the full TPC acceptance (+0.9)
 
  // Centrality Measurement
   static Float_t  fgEtaMid ;                                   // Mid-Rapidity interval, used for Centrality measurement
@@ -68,15 +109,18 @@ class AliFlowConstants {
   static Short_t  fgBeamMassNumberEast;                        // beam mass (Pb = 208)
   static Short_t  fgBeamMassNumberWest;                        // beam mass (Pb = 208)
 
- // ALICE detector measures ...
-  static Float_t fgITSx ;                                      // inner ITS radial distance from the interaction point
-  static Float_t fgTPCx ;                                      // inner TPC radial distance from the interaction point 
-  static Float_t fgTRDx ;                                      // inner TRD radial distance from the interaction point 
-  static Float_t fgTOFx ;                                      // inner TOF radial distance from the interaction point 
+ // ALICE detector measures
+  static Float_t  fgITSx ;                                     // inner ITS radial distance from the interaction point
+  static Float_t  fgTPCx ;                                     // inner TPC radial distance from the interaction point 
+  static Float_t  fgTRDx ;                                     // inner TRD radial distance from the interaction point 
+  static Float_t  fgTOFx ;                                     // inner TOF radial distance from the interaction point 
 
-  static Float_t fgMaxInt ;                                    // big number (to avoid infinity)
+ // ...
+  static Int_t    fgMClabel ;                                  // checking the simulation: pTrack->Label()<fMClabel = primary track 
+  static Bool_t   fgDebug ;                                    // for more cout statements (debugging purpose)
+  static Float_t  fgMaxInt ;                                   // big number (to avoid overflows)
 
-  ClassDef(AliFlowConstants,1)                                 // macro for rootcint
+  ClassDef(AliFlowConstants,2)                                 // macro for rootcint
 };
 
 #endif
index ccdb7f6c79e1919aaf068640464144737cd03647..f2a3ab13276bb7ecb783060095fe73e7bacf9385 100644 (file)
 //
 
 #include "AliFlowEvent.h"
+#include "AliFlowTrack.h"
+#include "AliFlowV0.h"
+#include "AliFlowSelection.h"
 #include "AliFlowConstants.h"
+
 #include "TVector.h"
 #include "TVector2.h"
 #include "TVector3.h"
+#include "TClonesArray.h"
+#include "TMath.h"
+#include "TRandom.h"
+#include "TString.h"
 #include <iostream>
 using namespace std; //required for resolving the 'cout' symbol
 
 // - Flags & Sets
-Bool_t  AliFlowEvent::fPtWgt          = kFALSE ;  // gives pT-based weights
-Bool_t  AliFlowEvent::fEtaWgt         = kFALSE ;  // gives eta-based weights
-Bool_t  AliFlowEvent::fOnePhiWgt       = kTRUE  ;  // kTRUE --> ENABLEs SINGLE WEIGHT ISTOGRAM , kFALSE --> ENABLEs 3 WEIGHT ISTOGRAMS
-Bool_t  AliFlowEvent::fNoWgt          = kFALSE ;  // No Weight is used
+Bool_t  AliFlowEvent::fgPtWgt         = kFALSE ;  // gives pT-based weights
+Bool_t  AliFlowEvent::fgEtaWgt        = kFALSE ;  // gives eta-based weights
+Bool_t  AliFlowEvent::fgOnePhiWgt       = kTRUE  ;  // kTRUE --> ENABLEs SINGLE WEIGHT ISTOGRAM , kFALSE --> ENABLEs 3 WEIGHT ISTOGRAMS
+Bool_t  AliFlowEvent::fgNoWgt         = kFALSE ;  // No Weight is used
 // - Eta Sub-Events (later used to calculate the resolution)
-Bool_t  AliFlowEvent::fEtaSubs                = kFALSE ;  // makes eta subevents
+Bool_t  AliFlowEvent::fgEtaSubs               = kFALSE ;  // makes eta subevents
 
 ClassImp(AliFlowEvent) 
 //-----------------------------------------------------------
@@ -61,14 +69,15 @@ AliFlowEvent::AliFlowEvent(Int_t lenght)
  fEventID = 0 ; 
  fRunID = 0 ;                 
  fOrigMult = 0 ;
- fL0TriggerWord = 0 ;                         
+ fL0Trigger = 0 ;                             
  fCentrality = -1 ;
  fZDCpart = 0 ;
  for(int zz=0;zz<3;zz++) { fZDCenergy[zz] = 0. ; }
+ for(int i=0;i<AliFlowConstants::kHars;i++) { fExtPsi[i] = 0. ; fExtRes[i] = 0.; }
  
  // Make a new track collection
- fTrackCollection =  new TObjArray(lenght) ;
- fV0Collection =  new TObjArray(0) ;
+ fTrackCollection =  new TClonesArray("AliFlowTrack",lenght) ; fTrackCollection->BypassStreamer(kTRUE) ;
+ fV0Collection    =  new TClonesArray("AliFlowV0",lenght)    ; fV0Collection->BypassStreamer(kTRUE)    ;
  
  // Set Weights Arrays to 1 (default)
  for(int nS=0;nS<AliFlowConstants::kSels;nS++)
@@ -152,10 +161,10 @@ Double_t AliFlowEvent::Weight(Int_t selN, Int_t harN, AliFlowTrack* pFlowTrack)
 Double_t AliFlowEvent::PhiWeight(Int_t selN, Int_t harN, AliFlowTrack* pFlowTrack) const
 {
  // Weight for making the event plane isotropic in the lab and enhancing the resolution
- // (it simply rerurns PhiWeightRaw() * Weight()). If fNoWgt = kTRUE, returns +/-1 ,
+ // (it simply rerurns PhiWeightRaw() * Weight()). If fgNoWgt = kTRUE, returns +/-1 ,
  // basing on Sign(eta), for odd harmonics .
  
- if(fNoWgt) // no weights (but +/- according to eta)
+ if(fgNoWgt) // no weights (but +/- according to eta)
  { 
   bool oddHar = (harN+1) % 2 ;
   if(oddHar) { return TMath::Sign((Double_t)1.,(Double_t)pFlowTrack->Eta()) ; }
@@ -168,7 +177,7 @@ Double_t AliFlowEvent::PhiWeight(Int_t selN, Int_t harN, AliFlowTrack* pFlowTrac
  return phiWgtRaw * weight;
 }
 //-------------------------------------------------------------
-Int_t AliFlowEvent::Mult(AliFlowSelection* pFlowSelect)        
+Int_t AliFlowEvent::Mult(AliFlowSelection* pFlowSelect) const  
 {
  // Multiplicity of tracks in the specified Selection 
  
@@ -190,7 +199,7 @@ Int_t AliFlowEvent::Mult(AliFlowSelection* pFlowSelect)
  return mult;
 }
 //-------------------------------------------------------------
-Float_t AliFlowEvent::MeanPt(AliFlowSelection* pFlowSelect)
+Float_t AliFlowEvent::MeanPt(AliFlowSelection* pFlowSelect) const
 {
  // Mean pt of tracks in the specified Selection 
 
@@ -213,7 +222,7 @@ Float_t AliFlowEvent::MeanPt(AliFlowSelection* pFlowSelect)
  return meanPt ;
 }
 //-------------------------------------------------------------
-TVector2 AliFlowEvent::Q(AliFlowSelection* pFlowSelect)
+TVector2 AliFlowEvent::Q(AliFlowSelection* pFlowSelect) const
 {
  // Event plane vector for the specified Selection 
 
@@ -249,7 +258,7 @@ TVector2 AliFlowEvent::Q(AliFlowSelection* pFlowSelect)
  return mQ;
 }
 //-------------------------------------------------------------
-Float_t AliFlowEvent::Psi(AliFlowSelection* pFlowSelect)
+Float_t AliFlowEvent::Psi(AliFlowSelection* pFlowSelect) const
 {
  // Event plane angle for the specified Selection 
 
@@ -266,22 +275,22 @@ Float_t AliFlowEvent::Psi(AliFlowSelection* pFlowSelect)
  return psi;
 }
 //-------------------------------------------------------------
-TVector2 AliFlowEvent::NormQ(AliFlowSelection* pFlowSelect)    
+TVector2 AliFlowEvent::NormQ(AliFlowSelection* pFlowSelect) const      
 {
  // Normalized Q = Q/sqrt(sum of weights^2) for the specified Selection 
 
  if(fDone) 
  {
   TVector2 mQ = fQ[pFlowSelect->Sel()][pFlowSelect->Har()] ;   
-  double SumOfWeightSqr = fSumOfWeightSqr[pFlowSelect->Sel()][pFlowSelect->Har()] ;
-  if(SumOfWeightSqr) { mQ /= TMath::Sqrt(SumOfWeightSqr) ; }
+  double sumOfWeightSqr = fSumOfWeightSqr[pFlowSelect->Sel()][pFlowSelect->Har()] ;
+  if(sumOfWeightSqr) { mQ /= TMath::Sqrt(sumOfWeightSqr) ; }
   else { mQ.Set(0.,0.) ; }
   return mQ ;
  }
  // -
  TVector2 mQ ;
  Double_t mQx=0. , mQy=0. ;
- double SumOfWeightSqr = 0 ;
+ double sumOfWeightSqr = 0 ;
  int selN     = pFlowSelect->Sel() ;
  int harN     = pFlowSelect->Har() ;
  double order = (double)(harN + 1) ;
@@ -293,20 +302,20 @@ TVector2 AliFlowEvent::NormQ(AliFlowSelection* pFlowSelect)
   if (pFlowSelect->Select(pFlowTrack)) 
   {
    double phiWgt = PhiWeight(selN, harN, pFlowTrack);
-   SumOfWeightSqr += phiWgt*phiWgt;
+   sumOfWeightSqr += phiWgt*phiWgt;
 
    float phi = pFlowTrack->Phi();
    mQx += phiWgt * cos(phi * order);
    mQy += phiWgt * sin(phi * order);
   }
  }
- if(SumOfWeightSqr) { mQ.Set(mQx/TMath::Sqrt(SumOfWeightSqr), mQy/TMath::Sqrt(SumOfWeightSqr)); }
+ if(sumOfWeightSqr) { mQ.Set(mQx/TMath::Sqrt(sumOfWeightSqr), mQy/TMath::Sqrt(sumOfWeightSqr)); }
  else { mQ.Set(0.,0.); }
   
  return mQ;
 }
 //-------------------------------------------------------------
-Float_t AliFlowEvent::q(AliFlowSelection* pFlowSelect) 
+Float_t AliFlowEvent::OldQ(AliFlowSelection* pFlowSelect) const 
 { 
  // Magnitude of normalized Q vector (without pt or eta weighting) for the specified Selection 
 
@@ -315,7 +324,7 @@ Float_t AliFlowEvent::q(AliFlowSelection* pFlowSelect)
  int selN     = pFlowSelect->Sel() ;
  int harN     = pFlowSelect->Har() ;
  double order = (double)(harN + 1) ;
- double SumOfWeightSqr = 0 ;
+ double sumOfWeightSqr = 0 ;
 
  Int_t itr ;
  for(itr=0;itr<TrackCollection()->GetEntries();itr++) 
@@ -325,19 +334,19 @@ Float_t AliFlowEvent::q(AliFlowSelection* pFlowSelect)
   if(pFlowSelect->Select(pFlowTrack)) 
   {
    double phiWgt = PhiWeightRaw(selN, harN, pFlowTrack); // Raw
-   SumOfWeightSqr += phiWgt*phiWgt;
+   sumOfWeightSqr += phiWgt*phiWgt;
    float phi = pFlowTrack->Phi();
    mQx += phiWgt * cos(phi * order);
    mQy += phiWgt * sin(phi * order);
   }
  }
- if(SumOfWeightSqr) { mQ.Set(mQx/TMath::Sqrt(SumOfWeightSqr), mQy/TMath::Sqrt(SumOfWeightSqr)); }
+ if(sumOfWeightSqr) { mQ.Set(mQx/TMath::Sqrt(sumOfWeightSqr), mQy/TMath::Sqrt(sumOfWeightSqr)); }
  else { mQ.Set(0.,0.); }
   
  return mQ.Mod();
 }
 //-----------------------------------------------------------------------
-Double_t AliFlowEvent::G_New(AliFlowSelection* pFlowSelect, Double_t Zx, Double_t Zy)
+Double_t AliFlowEvent::NewG(AliFlowSelection* pFlowSelect, Double_t Zx, Double_t Zy) const
 { 
  // Generating function for the new cumulant method. Eq. 3 in the Practical Guide 
 
@@ -363,29 +372,25 @@ Double_t AliFlowEvent::G_New(AliFlowSelection* pFlowSelect, Double_t Zx, Double_
  return theG;
 }
 //-----------------------------------------------------------------------
-Double_t AliFlowEvent::G_Old(AliFlowSelection* pFlowSelect, Double_t Zx, Double_t Zy) 
+Double_t AliFlowEvent::OldG(AliFlowSelection* pFlowSelect, Double_t Zx, Double_t Zy) const
 { 
  // Generating function for the old cumulant method (if expanded in Taylor
- // series, one recovers G_New() in new new cumulant method)
+ // series, one recovers NewG() in new new cumulant method)
 
- TVector2 normQ = NormQ(pFlowSelect);
+ TVector2 normQ = NormQ(pFlowSelect) ;
 
  return exp(2*Zx*normQ.X() + 2*Zy*normQ.Y());
 }
 //-----------------------------------------------------------------------
-Double_t AliFlowEvent::SumWeightSquare(AliFlowSelection* pFlowSelect)
+Double_t AliFlowEvent::SumWeightSquare(AliFlowSelection* pFlowSelect) const
 {
  // Return sum of weights^2 for the specified Selection (used for normalization)
 
- if(fDone) 
- { 
-  return fSumOfWeightSqr[pFlowSelect->Sel()][pFlowSelect->Har()] ; 
- }
- // -
+ if(fDone) { return fSumOfWeightSqr[pFlowSelect->Sel()][pFlowSelect->Har()] ; }
+
  int selN = pFlowSelect->Sel();
  int harN = pFlowSelect->Har();
- Double_t SumOfWeightSqr = 0;
-
+ Double_t sumOfWeightSqr = 0;
  Int_t itr ;
  for(itr=0;itr<TrackCollection()->GetEntries();itr++) 
  {
@@ -394,15 +399,15 @@ Double_t AliFlowEvent::SumWeightSquare(AliFlowSelection* pFlowSelect)
   if (pFlowSelect->Select(pFlowTrack)) 
   {
    double phiWgt = PhiWeight(selN, harN, pFlowTrack);
-   SumOfWeightSqr += phiWgt*phiWgt;
+   sumOfWeightSqr += phiWgt*phiWgt;
   }
  }
- if(SumOfWeightSqr < 0.) { return Mult(pFlowSelect) ; }
+ if(sumOfWeightSqr < 0.) { return Mult(pFlowSelect) ; }
 
- return SumOfWeightSqr;
+ return sumOfWeightSqr;
 }
 //-------------------------------------------------------------
-Double_t AliFlowEvent::WgtMult_q4(AliFlowSelection* pFlowSelect)
+Double_t AliFlowEvent::WgtMultQ4(AliFlowSelection* pFlowSelect) const 
 { 
  // Used only for the old cumulant method, for getting q4 when weight is on.
  // Replace multiplicity in Eq.(74b) by this quantity when weight is on.
@@ -438,7 +443,7 @@ Double_t AliFlowEvent::WgtMult_q4(AliFlowSelection* pFlowSelect)
  return (theSumOfWgtSqr*theSumOfWgtSqr)/(theMult*(-theMeanWj4+2*theMeanWj2*theMeanWj2));
 }
 //-------------------------------------------------------------
-Double_t AliFlowEvent::WgtMult_q6(AliFlowSelection* pFlowSelect)
+Double_t AliFlowEvent::WgtMultQ6(AliFlowSelection* pFlowSelect) const 
 { 
  // Used only for the old cumulant method. For getting q6 when weight is on.
  // Replace multiplicity in Eq.(74c) by this quantity when weight is on.
@@ -524,7 +529,7 @@ void AliFlowEvent::SetSelections(AliFlowSelection* pFlowSelect)
    }
   }
   double eta = (double)(pFlowTrack->Eta());      
-  float  Pt  = pFlowTrack->Pt();                
+  float  pt  = pFlowTrack->Pt();                
   float  gDca = pFlowTrack->Dca() ;                    
 
  // Global DCA - gets rid of the track with DCA outside the range
@@ -541,18 +546,22 @@ void AliFlowEvent::SetSelections(AliFlowSelection* pFlowSelect)
    // Eta - gets rid of the track with Eta outside the range
     if((pFlowSelect->EtaCutHi(harN%2,selN)>pFlowSelect->EtaCutLo(harN%2,selN)) && (TMath::Abs(eta)<pFlowSelect->EtaCutLo(harN%2,selN) || TMath::Abs(eta)>pFlowSelect->EtaCutHi(harN%2,selN))) continue ; 
    // Pt - gets rid of the track with Pt outside the range
-    if((pFlowSelect->PtCutHi(harN%2,selN)>pFlowSelect->PtCutLo(harN%2,selN)) && (Pt<pFlowSelect->PtCutLo(harN%2,selN) || Pt>pFlowSelect->PtCutHi(harN%2,selN))) continue ; 
+    if((pFlowSelect->PtCutHi(harN%2,selN)>pFlowSelect->PtCutLo(harN%2,selN)) && (pt<pFlowSelect->PtCutLo(harN%2,selN) || pt>pFlowSelect->PtCutHi(harN%2,selN))) continue ; 
   
     pFlowTrack->SetSelect(harN, selN) ;  // if cuts defined (low<high) && track is in the range -> Set [har][sel] Flag ON
 
     if(AliFlowConstants::fgDebug) 
     {
-     cout << " harN " << harN%2 << " ,  selN " << selN << " - si" << endl ;
-     if(pFlowSelect->Pid()[0] != '\0') { cout << " track:  pid  " << pFlowTrack->Pid() << " = "<< pFlowSelect->Pid() << endl ; } 
-     cout << " track:  dca  " << pFlowSelect->DcaGlobalCutLo() << " < " << gDca << " < " << pFlowSelect->DcaGlobalCutHi() << endl ;
-     cout << " track:  eta  " << pFlowSelect->EtaCutLo(harN,selN) << " < |" << eta << "| < " << pFlowSelect->EtaCutHi(harN,selN) << endl ;
-     cout << " track:  pT   " << pFlowSelect->PtCutLo(harN,selN) << " < " << Pt << " < " << pFlowSelect->PtCutHi(harN,selN) << endl ;
-     pFlowTrack->PrintSelection() ;
+     if(harN==1)
+     {
+      cout << " n. " << itr << " , pFlowTrack->PrintSelection() = " ; pFlowTrack->PrintSelection() ;
+      if(pFlowSelect->Pid()[0] != '\0') { cout << " track:  pid  " << pFlowTrack->Pid() << " = "<< pFlowSelect->Pid() << endl ; } 
+      cout << " track:  dca  " << pFlowSelect->DcaGlobalCutLo() << " < " << gDca << " < " << pFlowSelect->DcaGlobalCutHi() << endl ;
+      cout << " track:  eta  " << pFlowSelect->EtaCutLo(harN,selN) << " < |" << eta << "| < " << pFlowSelect->EtaCutHi(harN,selN) << endl ;
+      cout << " track:  pT   " << pFlowSelect->PtCutLo(harN,selN) << " < " << pt << " < " << pFlowSelect->PtCutHi(harN,selN) << endl ;
+      cout << " pFlowTrack->PrintSelection() = " ; pFlowTrack->PrintSelection() ;
+     }
+     // cout << " selN " << selN << " ,  harN " << harN%2 << " - si" << endl ;
     }
    }
   }
@@ -563,32 +572,32 @@ void AliFlowEvent::SetPids()
 {
  // Re-sets the tracks P.id. (using the current AliFlowConstants::fgBayesian[] array)
  
- const Int_t code[] = {11,13,211,321,2212,10010020} ;
+ const Int_t kCode[] = {11,13,211,321,2212,10010020} ;
  for(Int_t itr=0;itr<TrackCollection()->GetEntries();itr++) 
  {
   AliFlowTrack* pFlowTrack ;
   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
   TVector bayPid = pFlowTrack->PidProbs() ;
   Int_t maxN = 2 ;                // if No id. -> then is a Pi
-  Float_t pid_max = bayPid[2] ;    // (if all equal, Pi probability get's the advantage to be the first)
+  Float_t pidMax = bayPid[2] ;    // (if all equal, Pi probability get's the advantage to be the first)
   for(Int_t nP=0;nP<AliFlowConstants::kPid;nP++)
   {
-   if(bayPid[nP]>pid_max) { maxN = nP ; pid_max = bayPid[nP] ; }
+   if(bayPid[nP]>pidMax) { maxN = nP ; pidMax = bayPid[nP] ; }
   }
-  Int_t pdg_code = TMath::Sign(code[maxN],pFlowTrack->Charge()) ;     
-  pFlowTrack->SetMostLikelihoodPID(pdg_code);                  
+  Int_t pdgCode = TMath::Sign(kCode[maxN],pFlowTrack->Charge()) ;     
+  pFlowTrack->SetMostLikelihoodPID(pdgCode);                   
  }
 }
 //-------------------------------------------------------------
-void AliFlowEvent::MakeSubEvents() 
+void AliFlowEvent::MakeSubEvents() const
 {
  // Make random or eta sub-events
  
- if(EtaSubs())  { MakeEtaSubEvents() ; }
+ if(fgEtaSubs)  { MakeEtaSubEvents() ; }
  else          { MakeRndSubEvents() ; }
 } 
 //-------------------------------------------------------------
-void AliFlowEvent::MakeRndSubEvents() 
+void AliFlowEvent::MakeRndSubEvents() const 
 {
  // Make random subevents
  
@@ -635,10 +644,10 @@ void AliFlowEvent::MakeRndSubEvents()
  return ; 
 }
 //-------------------------------------------------------------
-void AliFlowEvent::MakeEtaSubEvents() 
+void AliFlowEvent::MakeEtaSubEvents() const
 {
  // Make subevents for positive and negative eta 
- // (when done, fEtaSubs flag setted to kTRUE).
+ // (when done, fgEtaSubs flag setted to kTRUE).
  
  int harN, selN = 0;
  // loop to set the SubEvent member
@@ -667,34 +676,37 @@ void AliFlowEvent::RandomShuffle()
  // primary, the reference carried by the reconstructed mother (in 
  // the v0 array) is changed accordingly.
 
- Int_t tot = 0 ;
- UInt_t imax = TrackCollection()->GetEntries() ;
- TRandom* rnd = new TRandom(0) ; // SetSeed(0) ;
- TObjArray* newTrackCollection = new TObjArray(imax) ;
-
- // re-arranges the ObjArray (TrackCollection())
- for(UInt_t itr=0;itr<imax;itr++)
- {
-  AliFlowTrack* pFlowTrack ;
-  pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
-  
-  UInt_t rndNumber = rnd->Integer(imax) ;
-  Bool_t put = kFALSE ;
-  while(!put)
-  { 
-   if(!newTrackCollection->At(rndNumber)) 
-   { 
-    newTrackCollection->AddAt(pFlowTrack, rndNumber) ; 
-    put = kTRUE ; tot++ ;              if(AliFlowConstants::fgDebug) { cout << "  " << itr << " --> " << rndNumber << endl ; } 
-   }
-   else 
-   {
-    rndNumber++ ; if(rndNumber>=imax) { rndNumber -= imax ; }
-   }
-  }
- }
- if(AliFlowConstants::fgDebug) { cout << "* RandomShuffle() :  " << tot << "/" << imax << " flow tracks have been shuffled " << endl ; }  
- fTrackCollection = newTrackCollection ;
+ return ; // ...at the moment is disabled ... // 
+//  Int_t tot = 0 ;
+//  UInt_t imax = fTrackCollection->GetEntries() ;
+//  TRandom* rnd = new TRandom(0) ; // SetSeed(0) ;
+//  TClonesArray* newTrackCollection = new TClonesArray("AliFlowTrack",imax) ;
+// 
+//  // re-arranges the ObjArray (TrackCollection())
+//  for(UInt_t itr=0;itr<imax;itr++)
+//  {
+//   AliFlowTrack* pFlowTrack ;
+//   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
+//   
+//   UInt_t rndNumber = rnd->Integer(imax) ;
+//   Bool_t put = kFALSE ;
+//   while(!put)
+//   { 
+//    if(!newTrackCollection->AddrAt(rndNumber)) 
+//    { 
+//     ... new(newTrackCollection[rndNumber]) AliFlowTrack(*pFlowTrack)  ; 
+//     put = kTRUE ; tot++ ;           
+//     if(AliFlowConstants::fgDebug) { cout << "  " << itr << " --> " << rndNumber << endl ; } 
+//    }
+//    else 
+//    {
+//     rndNumber++ ; if(rndNumber>=imax) { rndNumber -= imax ; }
+//    }
+//   }
+//  }
+//  if(AliFlowConstants::fgDebug) { cout << "* RandomShuffle() :  " << tot << "/" << imax << " flow tracks have been shuffled " << endl ; }  
+//  fTrackCollection = newTrackCollection ;
 }
 //-----------------------------------------------------------------------
 UInt_t AliFlowEvent::Centrality() 
@@ -705,13 +717,6 @@ UInt_t AliFlowEvent::Centrality()
  return fCentrality ;
 }
 //-----------------------------------------------------------------------
-void AliFlowEvent::SetCentrality(Int_t cent) 
-{
- // Set the Centrality Classes to "cent" .
-
- fCentrality = cent ; 
-}
-//-----------------------------------------------------------------------
 void AliFlowEvent::SetCentrality() 
 {
  // Sets the Centrality Classes basing on Multiplicity at mid rapidity, 
@@ -737,7 +742,7 @@ void AliFlowEvent::SetCentrality()
  {
   cent = (Float_t*)AliFlowConstants::fgCent0 ;
  } 
- else // other definition of centrality are possible...
+ else // other definition of centrality are possible ...
  {
   cent = (Float_t*)AliFlowConstants::fgCent0 ;
  } 
@@ -755,15 +760,10 @@ void AliFlowEvent::SetCentrality()
  if(AliFlowConstants::fgDebug) { cout << " * Centrality Class :  " << fCentrality << " . " << endl ; }
 }
 //-----------------------------------------------------------------------
-void AliFlowEvent::Bayesian(Double_t bayes[AliFlowConstants::kPid]) 
-{
- // Returns bayesian array of particles' abundances (from AliFlowConstants::)
- for(Int_t i=0;i<AliFlowConstants::kPid;i++) { bayes[i] = AliFlowConstants::fgBayesian[i] ; }
-}
-//-----------------------------------------------------------------------
-TVector AliFlowEvent::Bayesian() 
+TVector AliFlowEvent::Bayesian() const 
 { 
+ // Returns bayesian array of particle abundances (from AliFlowConstants::)
  TVector bayes(AliFlowConstants::kPid) ; 
  for(Int_t i=0;i<AliFlowConstants::kPid;i++) { bayes[i] = AliFlowConstants::fgBayesian[i] ; }
  return bayes ;
@@ -795,18 +795,7 @@ void AliFlowEvent::PrintFlagList() const
  cout << "#######################################################" << endl;  
 }
 //-----------------------------------------------------------------------
-void AliFlowEvent::SetEventID(const Int_t& id)                   
-{ 
- // Sets Event ID and the Event name (name = evtNumber_runId)
- fEventID = id ; 
- TString name = "" ;
- name += fEventID ;
- if(fRunID) { name += "_" ; name += fRunID ; }
- SetName(name) ;  // from TNamed::SetName
-}
-//-----------------------------------------------------------------------
-Int_t AliFlowEvent::MultEta()
+Int_t AliFlowEvent::MultEta() const
 {
  // Returns the multiplicity in the interval |eta|<(AliFlowConstants::fgEetaMid), used 
  // for centrality measurement (see centrality classes in fCentrality) .
@@ -853,27 +842,18 @@ Int_t AliFlowEvent::UncorrPosMult(Float_t eta)  const
  return posMult; 
 }
 //-----------------------------------------------------------------------
-void AliFlowEvent::VertexPos(Float_t vtx[3])  const            
-{ 
- for(Int_t ii=0;ii<3;ii++) { vtx[ii] = fVertexPos[ii] ; }
-}
-//-----------------------------------------------------------------------
 TVector3 AliFlowEvent::VertexPos() const
 {
+ // Returns primary vertex position as a TVector3
+
  Float_t vertex[3] ;
  VertexPos(vertex) ;
  return TVector3(vertex) ;
 }
 //-----------------------------------------------------------------------
-void AliFlowEvent::SetVertexPos(Float_t v1,Float_t v2,Float_t v3)
-{ 
- fVertexPos[0] = v1 ; fVertexPos[1] = v2 ; fVertexPos[2] = v3 ; 
-}
-//-----------------------------------------------------------------------
 void AliFlowEvent::MakeAll()
 { 
- // calculates all quantities in 1 shoot ...
- //  ...
+ // calculates all quantities in 1 shoot 
 
  Double_t mQx[AliFlowConstants::kSels][AliFlowConstants::kHars] ;
  Double_t mQy[AliFlowConstants::kSels][AliFlowConstants::kHars] ;
@@ -945,103 +925,4 @@ void AliFlowEvent::MakeAll()
 
  fDone = kTRUE ;
 }
-// //-----------------------------------------------------------------------
-// Float_t  AliFlowEvent::ExtPsi(Int_t harN) const     
-// { 
-//  // external R.P. angle (check input source...)
-// 
-//  if(harN<AliFlowConstants::kHars) { return fExtPsi[harN] ; }
-//  else 
-//  { 
-//   cout << "AliFlowEvent::ExtPsi(" << harN << ") : harmonic " << harN+1 << " is not there !" << endl ; 
-//   return 0. ; 
-//  }
-// }
-// //-----------------------------------------------------------------------
-// Float_t  AliFlowEvent::ExtRes(Int_t harN) const
-// { 
-//  // external R.P. resolution (check input source...)
-// 
-//  if(harN<AliFlowConstants::kHars) { return fExtRes[harN] ; }
-//  else 
-//  { 
-//   cout << "AliFlowEvent::ExtRes(" << harN << ") : harmonic " << harN+1 << " is not there !" << endl ; 
-//   return 0. ; 
-//  }
-// }
-// //-----------------------------------------------------------------------
-// void AliFlowEvent::SetExtPsi(Int_t harN,Float_t psi)         
-// { 
-//  if(harN<AliFlowConstants::kHars) { fExtPsi[harN] = psi ; }
-// }
-// //-----------------------------------------------------------------------
-// void AliFlowEvent::SetExtRes(Int_t harN,Float_t res)         
-// { 
-//  if(harN<AliFlowConstants::kHars) { fExtRes[harN] = res ; }
-// }
-// //-----------------------------------------------------------------------
-
-
-
-//-----------------------------------------------------------------------
-// - those will go into the .h as inline functions ..................... 
-//-----------------------------------------------------------------------
-TObjArray* AliFlowEvent::TrackCollection() const       { return fTrackCollection; }
-TObjArray* AliFlowEvent::V0Collection() const          { return fV0Collection; }
-//-----------------------------------------------------------------------
-Int_t   AliFlowEvent::EventID() const                  { return fEventID; }
-Int_t   AliFlowEvent::RunID() const                    { return fRunID; }
-Double_t AliFlowEvent::CenterOfMassEnergy() const      { return AliFlowConstants::fgCenterOfMassEnergy ; }
-Double_t AliFlowEvent::MagneticField() const           { return AliFlowConstants::fgMagneticField ; }
-Short_t  AliFlowEvent::BeamMassNumberEast() const      { return AliFlowConstants::fgBeamMassNumberEast ; }
-Short_t  AliFlowEvent::BeamMassNumberWest() const      { return AliFlowConstants::fgBeamMassNumberWest ; }
-UInt_t   AliFlowEvent::OrigMult() const                { return fOrigMult; }
-Long_t   AliFlowEvent::L0TriggerWord() const           { return fL0TriggerWord; }
-Int_t    AliFlowEvent::V0Mult() const                  { return V0Collection()->GetEntries() ; }
-Int_t    AliFlowEvent::FlowEventMult() const           { return TrackCollection()->GetEntries() ; }
-Int_t    AliFlowEvent::ZDCpart() const                 { return fZDCpart; }
-Float_t  AliFlowEvent::ZDCenergy(Int_t npem) const     { return fZDCenergy[npem]; }
-Float_t  AliFlowEvent::PtWgtSaturation() const         { return AliFlowConstants::fgPtWgtSaturation; }
-Bool_t   AliFlowEvent::PtWgt() const                   { return fPtWgt; }
-Bool_t   AliFlowEvent::EtaWgt() const                  { return fEtaWgt; }
-Bool_t   AliFlowEvent::FirstLastPhiWgt() const         { return !fOnePhiWgt ; }
-Bool_t   AliFlowEvent::OnePhiWgt() const               { return fOnePhiWgt ; }
-Bool_t   AliFlowEvent::NoWgt() const                   { return fNoWgt; }
-Bool_t   AliFlowEvent::EtaSubs() const                 { return fEtaSubs ; }
-//-----------------------------------------------------------------------
-void            AliFlowEvent::SetEtaSubs(Bool_t etasub)                      { fEtaSubs = etasub ; }
-void    AliFlowEvent::SetRunID(const Int_t& id)                      { fRunID = id; }
-void    AliFlowEvent::SetMagneticField(const Double_t& mf)           { AliFlowConstants::fgMagneticField = mf; }
-void    AliFlowEvent::SetCenterOfMassEnergy(const Double_t& cms)     { AliFlowConstants::fgCenterOfMassEnergy = cms; }
-void    AliFlowEvent::SetBeamMassNumberEast(const Short_t& bme)      { AliFlowConstants::fgBeamMassNumberEast = bme; }
-void    AliFlowEvent::SetBeamMassNumberWest(const Short_t& bmw)      { AliFlowConstants::fgBeamMassNumberWest = bmw; }
-void    AliFlowEvent::SetOrigMult(const UInt_t& tracks)              { fOrigMult = tracks; }
-void    AliFlowEvent::SetL0TriggerWord(const Long_t& trigger)        { fL0TriggerWord = trigger; }
-void    AliFlowEvent::SetZDCpart(Int_t zdcp)                         { fZDCpart = zdcp ; }
-void    AliFlowEvent::SetZDCenergy(Float_t n, Float_t p, Float_t em) { fZDCenergy[0] = n ; fZDCenergy[1] = p ; fZDCenergy[2] = em ; }
-//-----------------------------------------------------------------------
-void AliFlowEvent::SetBayesian(Double_t bayes[AliFlowConstants::kPid])           
-{ 
- for(Int_t i=0;i<AliFlowConstants::kPid;i++) { AliFlowConstants::fgBayesian[i] = bayes[i] ; } 
-}
-//-----------------------------------------------------------------------
-void AliFlowEvent::SetNoWgt(Bool_t nowgt) 
-{ 
- // Sets no phi weightening, but Wgt = 1*sign(Eta) for odd harmonics .
- fNoWgt = nowgt ; // cout << " Wgt = +1 (positive Eta) or -1 (negative Eta) . " << endl ;
-}
-//-----------------------------------------------------------------------
-void AliFlowEvent::SetOnePhiWgt()                                { fOnePhiWgt = kTRUE ; }
-void AliFlowEvent::SetFirstLastPhiWgt()                          { fOnePhiWgt = kFALSE ; }
-void AliFlowEvent::SetPtWgt(Bool_t PtWgt)                        { fPtWgt = PtWgt; }
-void AliFlowEvent::SetEtaWgt(Bool_t EtaWgt)                      { fEtaWgt = EtaWgt; }
 //-----------------------------------------------------------------------
-#ifndef __CINT__
-void AliFlowEvent::SetPhiWeight(const AliFlowConstants::PhiWgt_t& pPhiWgt)          { memcpy (fPhiWgt, pPhiWgt, sizeof(AliFlowConstants::PhiWgt_t)); }
-void AliFlowEvent::SetPhiWeightPlus(const AliFlowConstants::PhiWgt_t& pPhiWgtPlus)   { memcpy (fPhiWgtPlus,  pPhiWgtPlus,  sizeof(AliFlowConstants::PhiWgt_t)); }
-void AliFlowEvent::SetPhiWeightMinus(const AliFlowConstants::PhiWgt_t& pPhiWgtMinus) { memcpy (fPhiWgtMinus, pPhiWgtMinus, sizeof(AliFlowConstants::PhiWgt_t)); }
-void AliFlowEvent::SetPhiWeightCross(const AliFlowConstants::PhiWgt_t& pPhiWgtCross) { memcpy (fPhiWgtCross, pPhiWgtCross, sizeof(AliFlowConstants::PhiWgt_t)); }
-#endif
-//-----------------------------------------------------------------------
-//////////////////////////////////////////////////////////////////////
index 502c7babda158675edeadf0cc3e71a169d979c84..2909c7a8418569b78bf354624691191782d74071 100644 (file)
@@ -6,7 +6,11 @@
 //
 //////////////////////////////////////////////////////////////////////
 //
-// Description: event format fitted to flow study, adapted from STAR 
+// Description: event format fitted to flow study, adapted from STAR.
+//  The AliFlowEvent object stores global event variables, tracks and  
+//  v0s, and provides the method to calculate Flow observables (Q vector, 
+//  R.P. angle, phi weights). It needs an AliFlowSelection object.
+//
 // Original Authors:               Raimond Snellings & Art Poskanzer
 //
 //////////////////////////////////////////////////////////////////////
 #ifndef AliFlowEvent_h
 #define AliFlowEvent_h
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <iostream>
 #include "TVector.h"
 #include "TVector2.h"
 #include "TVector3.h"
-#include "TObject.h"
-#include "TRandom.h"
-#include "TObjArray.h"
-#include <TROOT.h>
-
-#include "AliFlowTrack.h"
-#include "AliFlowV0.h"
-#include "AliFlowSelection.h"
+#include "TClonesArray.h"
+#include "TNamed.h"
+
 #include "AliFlowConstants.h"
 
 class AliFlowTrack ;
@@ -38,129 +34,131 @@ class AliFlowEvent : public TNamed {
 
 public:                                                                           
                                                                                   
-  AliFlowEvent(Int_t length = 1000) ;                                             
+  AliFlowEvent(Int_t length = 20000) ;                                                    
   virtual        ~AliFlowEvent();                                                 
                                                                                   
- // Gets
-  Int_t          EventID()             const;                                  // Returns ID of the event
-  Int_t          RunID()               const;                                  // Returns ID of the run
-  Long_t         L0TriggerWord()       const;                                  // Returns L0 trigger word
-  Int_t          ZDCpart()             const;                                  // Returns estimated number of participants by the ZDC
-  Float_t        ZDCenergy(Int_t npem) const;                                  // Returns reconstructed energy in the neutron(1), proton(2), em(3) ZDC
-  void           VertexPos(Float_t vtx[3]) const;                              // Returns primary vertex position
-  TVector3       VertexPos()           const;                                  // Returns primary vertex position as a TVector3
-  UInt_t         Centrality() ;                                                        // Returns centrality bin (based on MultEta() )
-  UInt_t         OrigMult()            const;                                  // Returns the original number of tracks (maybe some were trown away)
-  Int_t         V0Mult()               const;                                  // Returns the number of V0s 
-  Int_t          FlowEventMult()       const;                                  // Returns number of tracks stored in the event
-  Int_t          UncorrNegMult(Float_t eta = AliFlowConstants::fgEtaGood) const ; // Returns number of - tracks in eta (-eta;eta)
-  Int_t          UncorrPosMult(Float_t eta = AliFlowConstants::fgEtaGood) const ; // Returns number of + tracks in eta (-eta;eta)
-  Int_t          MultEta() ;                                                   // Returns multiplicity in |eta|<AliFlowConstants::fgEetaMid
-  Double_t       CenterOfMassEnergy()  const;                                  // Returns center of mass energy (5.5 TeV)
-  Double_t       MagneticField()       const;                                  // Returns magnetic field value
-  Short_t        BeamMassNumberEast()  const;                                  // Returns beam mass (Pb = 208)
-  Short_t        BeamMassNumberWest()  const;                                  // Returns beam mass (Pb = 208)
-
-                                                                         
- // Sets
-  void          SetEventID(const Int_t&);
-  void          SetRunID(const Int_t&);
-  void          SetCenterOfMassEnergy(const Double_t&);
-  void          SetMagneticField(const Double_t&);
-  void           SetCentrality() ; 
-  void           SetCentrality(Int_t cent) ; 
-  void          SetBeamMassNumberEast(const Short_t&);
-  void          SetBeamMassNumberWest(const Short_t&);
-  void          SetOrigMult(const UInt_t&);
-  void          SetL0TriggerWord(const Long_t&);
-  void          SetVertexPos(Float_t v1=0.,Float_t v2=0.,Float_t v3=0.);
-  void          SetZDCpart(Int_t zdcp);
-  void          SetZDCenergy(Float_t n, Float_t p, Float_t em);
-
-//  // new
-//   void               SetExtPsi(Int_t harN, Float_t psi=0.) ;
-//   void               SetExtRes(Int_t harN, Float_t res=0.) ;
-//   Float_t    ExtPsi(Int_t harN)     const ;                                 // external RP angle
-//   Float_t    ExtRes(Int_t harN)     const ;                                 // external RP resolution
-
  // Arrays
-  TObjArray*     TrackCollection()     const;                                  // Returns a pointer to the TObjArray of AliFlowTrack
-  TObjArray*     V0Collection()        const;                                  // Returns a pointer to the TObjArray of AliFlowV0
+  TClonesArray*     TrackCollection() const        { return fTrackCollection; }  // Returns a pointer to the TClonesArray of AliFlowTrack
+  TClonesArray*     V0Collection() const          { return fV0Collection; }     // Returns a pointer to the TClonesArray of AliFlowV0
 
  // Calculations
-  Int_t          Mult(AliFlowSelection*);                                      // Returns Multiplicity of tracks selected for the event plane
-  TVector2       Q(AliFlowSelection*);                                         // Returns Event plane vector
-  Float_t        q(AliFlowSelection*);                                         // Returns Magnitude of normalized Q vector without pt or eta weighting
-  Float_t        MeanPt(AliFlowSelection*);                                    // Returns Mean pt of tracks selected for the event plane
-  Float_t        Psi(AliFlowSelection*);                                       // Returns Event plane angle
-  Double_t       G_New(AliFlowSelection* pFlowSelect,Double_t Zx,Double_t Zy); // Generating function for the new cumulant method (eq.3 in the Practical Guide)
-  Double_t       G_Old(AliFlowSelection* pFlowSelect,Double_t Zx,Double_t Zy); // Generating function for the old cumulant method (if expanded in Taylor series, one recovers G_New() in new new cumulant method)
-  Double_t       SumWeightSquare(AliFlowSelection* pFlowSelect);               // Returns Sum of weights^2
-  Double_t       WgtMult_q4(AliFlowSelection* pFlowSelect);                    // old comulants
-  Double_t       WgtMult_q6(AliFlowSelection* pFlowSelect);                    // old comulants
-  TVector2       NormQ(AliFlowSelection* pFlowSelect);                         // Returns normalized Q = Q/sqrt(weights^2++)
- // -
-  void          SetSelections(AliFlowSelection* pFlowSelect) ;                 // Sets the tracks selection for R.P. calculations (see static cuts in AliFlowSelection class)
-  void          RandomShuffle() ;                                              // Randomly re-shuffles the ObjArray of tracks
-  void          MakeSubEvents() ;                                              // Makes sub-events, eta based (if EtaSubs()) or Random (otherwise)
-  void          MakeRndSubEvents() ;                                           // Makes random sub-events
-  void          MakeEtaSubEvents() ;                                           // Makes eta sub-events
-  void                  SetPids() ;                                                    // Re-sets the tracks P.id. (using the current fBayesianCs[] array)
- // -
-  void          MakeAll() ;                                                    // In just one loop, makes all the calculaton (Q, psi, mult) basing on the selection. 
-
- // Weights & settings
-  Float_t        PtWgtSaturation()     const;                                  // Returns saturation value for pt weighting
-  Bool_t         PtWgt()               const;                                  // Returns flag for pt weighting
-  Bool_t         EtaWgt()              const;                                  // Returns flag for eta weighting for odd harmonics
-  Bool_t         FirstLastPhiWgt()     const;                                  // Returns flag for using z of first and last points for phi weights (TPC +/-)
-  Bool_t         OnePhiWgt()           const;                                  // Returns flag for using just one phi weight
-  Bool_t         NoWgt()               const;                                  // returns kTRUE if weight are NOT used
-  Double_t       PhiWeight(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;     // Returns PhiWeightRaw()*Weight()  
-  Double_t       PhiWeightRaw(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;  // Returns weights for making the R.P. isotropic in the lab
-  Double_t       Weight(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;        // Returns weights for enhancing the resolution (+/-Sign(eta) for odd harmonics)
-  void          Bayesian(Double_t bayes[AliFlowConstants::kPid]) ;                     // Returns the stored particles' abundances
-  TVector       Bayesian() ;                                                   // Returns the stored particles' abundances as a TVector
- // -
-  static void   SetPtWgt(Bool_t PtWgt = kTRUE);
-  static void   SetEtaWgt(Bool_t EtaWgt = kTRUE);
-  static void   SetOnePhiWgt();
-  static void   SetFirstLastPhiWgt();
-  static void   SetNoWgt(Bool_t nowgt = kTRUE) ;
- // -
-  void          SetBayesian(Double_t bayes[AliFlowConstants::kPid]) ;                  // Set the Bayesian vector of particles' abundances
-#ifndef __CINT__               
-  void          SetPhiWeight(const AliFlowConstants::PhiWgt_t &pPhiWgt);                       // Fills Weights from Arrays (from file: flowPhiWgt.hist.root)
-  void          SetPhiWeightPlus(const AliFlowConstants::PhiWgt_t &pPhiWgtPlus);
-  void          SetPhiWeightMinus(const AliFlowConstants::PhiWgt_t &pPhiWgtMinus);
-  void          SetPhiWeightCross(const AliFlowConstants::PhiWgt_t &pPhiWgtCross);
-#endif
+  void              MakeAll() ;                                                 // In just one loop, makes all the calculaton (Q, psi, mult) basing on the selection. 
+  Int_t             Mult(AliFlowSelection* pFlowSelect) const ;                         // Returns Multiplicity of tracks selected for the event plane
+  Float_t           MeanPt(AliFlowSelection* pFlowSelect) const ;               // Returns Mean pt of tracks selected for the event plane
+  TVector2          Q(AliFlowSelection* pFlowSelect) const ;                    // Returns Event plane vector
+  TVector2          NormQ(AliFlowSelection* pFlowSelect) const ;                // Returns normalized Q = Q/sqrt(weights^2++)
+  Float_t           OldQ(AliFlowSelection* pFlowSelect) const ;                         // Returns Magnitude of normalized Q vector without pt or eta weighting
+  Float_t           Psi(AliFlowSelection* pFlowSelect) const ;                  // Returns Event plane angle
+  Double_t          SumWeightSquare(AliFlowSelection* pFlowSelect) const ;      // Returns Sum of weights^2
+  Double_t          WgtMultQ4(AliFlowSelection* pFlowSelect) const ;            // old comulants
+  Double_t          WgtMultQ6(AliFlowSelection* pFlowSelect) const ;            // old comulants
+  void              SetSelections(AliFlowSelection* pFlowSelect) ;              // Sets the tracks selection for R.P. calculations (see static cuts in AliFlowSelection class)
+  void              MakeSubEvents() const ;                                     // Makes sub-events, eta based (if EtaSubs()) or Random (otherwise)
+  void              MakeRndSubEvents() const ;                                  // Makes random sub-events
+  void              MakeEtaSubEvents() const ;                                  // Makes eta sub-events
+  void                     SetPids() ;                                                  // Re-sets the tracks P.id. (using the current fBayesianCs[] array)
+  void              RandomShuffle() ;                                           // Randomly re-shuffles the ObjArray of tracks
+  Double_t          NewG(AliFlowSelection* pFlowSelect,Double_t Zx,Double_t Zy) const ;  // Generating function for the new cumulant method (eq.3 in the Practical Guide)
+  Double_t          OldG(AliFlowSelection* pFlowSelect,Double_t Zx,Double_t Zy) const ;  // Generating function for the old cumulant method (if expanded in Taylor series, one recovers G_New() in new new cumulant method)
+  Double_t          PhiWeight(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;   // Returns PhiWeightRaw()*Weight()  
+  Double_t          PhiWeightRaw(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ; // Returns weights for making the R.P. isotropic in the lab
+  Double_t          Weight(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;      // Returns weights for enhancing the resolution (+/-Sign(eta) for odd harmonics)
+  TVector           Bayesian() const ;                                                  // Returns the stored particle abundances as a TVector
+  void                     Bayesian(Double_t bayes[AliFlowConstants::kPid]) const { for(Int_t i=0;i<AliFlowConstants::kPid;i++) { bayes[i] = AliFlowConstants::fgBayesian[i] ; } } // Returns the stored particle abundances
 
  // Analysis flags
-  Bool_t         EtaSubs() const;                                              // Returns flag for eta sub-events
-  static void   SetEtaSubs(Bool_t etasub = kTRUE) ;                            // Sets the flag for eta sub-events
-  void          PrintFlagList() const ;                                        // Prints a summary of the event's flag
+  void       PrintFlagList() const ;                                                 // Prints a summary of the event's flag
+  Float_t    PtWgtSaturation() const  { return AliFlowConstants::fgPtWgtSaturation; } // Returns saturation value for pt weighting
+  Bool_t     PtWgt() const           { return fgPtWgt; }                             // Returns flag for pt weighting
+  Bool_t     EtaWgt() const          { return fgEtaWgt; }                            // Returns flag for eta weighting for odd harmonics
+  Bool_t     FirstLastPhiWgt() const  { return !fgOnePhiWgt ; }                              // Returns flag for using z of first and last points for phi weights (TPC +/-)
+  Bool_t     OnePhiWgt() const       { return fgOnePhiWgt ; }                        // Returns flag for using just one phi weight
+  Bool_t     NoWgt() const           { return fgNoWgt; }                             // returns kTRUE if weight are NOT used
+  Bool_t     EtaSubs() const         { return fgEtaSubs ; }                          // Returns flag for eta sub-events
+
+ // Gets
+  Int_t      EventID() const               { return fEventID; }                          // Returns ID of the event
+  Int_t      RunID() const                 { return fRunID; }                            // Returns ID of the run
+  UInt_t     OrigMult() const              { return fOrigMult; }                         // Returns the original number of tracks (maybe some were trown away)
+  Long_t     L0TriggerWord() const         { return fL0Trigger; }                        // Returns L0 trigger word
+  Int_t      ZDCpart() const               { return fZDCpart; }                          // Returns estimated number of participants by the ZDC
+  Float_t    ZDCenergy(Int_t npem) const    { return fZDCenergy[npem]; }                 // Returns reconstructed energy in the neutron(1), proton(2), em(3) ZDC
+  Int_t      V0Mult() const                { return fV0Collection->GetEntries() ; }      // Returns the number of V0s 
+  Int_t      TrackMult() const             { return fTrackCollection->GetEntries() ; }   // Returns number of tracks stored in the event
+
+  Int_t      UncorrNegMult(Float_t eta = AliFlowConstants::fgEtaGood) const ; // Returns number of - tracks in eta (-eta;eta)
+  Int_t      UncorrPosMult(Float_t eta = AliFlowConstants::fgEtaGood) const ; // Returns number of + tracks in eta (-eta;eta)
+  Int_t      MultEta() const ;                                               // Returns multiplicity in |eta|<AliFlowConstants::fgEetaMid
+  UInt_t     Centrality() ;                                                  // Returns centrality class, if not there, it sets it with MultEta()
+  TVector3   VertexPos() const;                                              // Returns primary vertex position as a TVector3
+  void       VertexPos(Float_t vtx[3]) const { for(Int_t ii=0;ii<3;ii++) { vtx[ii] = fVertexPos[ii] ; }        }                         // Returns primary vertex position
+                                                                         
+  Float_t    ExtPsi(Int_t harN = 0) const    { if(harN<AliFlowConstants::kHars) { return fExtPsi[harN] ; } else { return 0. ; } } // external RP angle
+  Float_t    ExtRes(Int_t harN = 0) const    { if(harN<AliFlowConstants::kHars) { return fExtRes[harN] ; } else { return 0. ; } } // external RP resolution
+
+  Double_t CenterOfMassEnergy() const       { return AliFlowConstants::fgCenterOfMassEnergy ; }   // Returns center of mass energy (5.5 TeV)
+  Double_t MagneticField() const            { return AliFlowConstants::fgMagneticField ; }        // Returns magnetic field value
+  Short_t  BeamMassNumberEast() const       { return AliFlowConstants::fgBeamMassNumberEast ; }   // Returns beam mass (Pb = 208)
+  Short_t  BeamMassNumberWest() const       { return AliFlowConstants::fgBeamMassNumberWest ; }   // Returns beam mass (Pb = 208)
+
+ // Sets
+  void     SetEventID(const Int_t& id)                             { fEventID = id ; }  // Sets Event ID and the Event name (name = evtNumber_runId)
+  void     SetRunID(Int_t id)                                      { fRunID = id; }
+  void     SetOrigMult(UInt_t tracks)                              { fOrigMult = tracks; }
+  void     SetL0TriggerWord(Long_t trigger)                        { fL0Trigger = trigger; }
+  void     SetZDCpart(Int_t zdcp)                                  { fZDCpart = zdcp ; }
+  void     SetZDCenergy(Float_t n, Float_t p, Float_t em)          { fZDCenergy[0] = n ; fZDCenergy[1] = p ; fZDCenergy[2] = em ; }
+  void     SetVertexPos(Float_t v1=0.,Float_t v2=0.,Float_t v3=0.)  { fVertexPos[0] = v1 ; fVertexPos[1] = v2 ; fVertexPos[2] = v3 ; }
+
+  void            SetExtPsi(Int_t harN=0, Float_t psi=0.)                  { if(harN<AliFlowConstants::kHars) { fExtPsi[harN] = psi ; } }
+  void            SetExtRes(Int_t harN=0, Float_t res=0.)                  { if(harN<AliFlowConstants::kHars) { fExtRes[harN] = res ; } }
+
+  void     SetCentrality(Int_t cent)                               { fCentrality = cent ; } // Set the Centrality Classes to "cent"
+  void     SetCentrality() ;                                       // Sets the Centrality Classes basing on Multiplicity at mid rapidity
+
+  static void SetEtaSubs(Bool_t etasub = kTRUE)                    { fgEtaSubs = etasub ; }
+  static void SetOnePhiWgt()                                       { fgOnePhiWgt = kTRUE ; }
+  static void SetFirstLastPhiWgt()                                 { fgOnePhiWgt = kFALSE ; }
+  static void SetPtWgt(Bool_t ptWgt = kTRUE)                       { fgPtWgt = ptWgt; }
+  static void SetEtaWgt(Bool_t etaWgt = kTRUE)                     { fgEtaWgt = etaWgt ; }
+  static void SetNoWgt(Bool_t nowgt = kTRUE)                       { fgNoWgt = nowgt ; }  // still for odd harmonics: Wgt = +1 (positive Eta) or -1 (negative Eta)
+               
+  void    SetBayesian(Double_t bayes[AliFlowConstants::kPid]) const { for(Int_t i=0;i<AliFlowConstants::kPid;i++) { AliFlowConstants::fgBayesian[i] = bayes[i] ; } } // Set the Bayesian vector of particle abundances
+  void    SetMagneticField(const Double_t& mf) const               { AliFlowConstants::fgMagneticField = mf; }
+  void    SetCenterOfMassEnergy(const Double_t& cms) const         { AliFlowConstants::fgCenterOfMassEnergy = cms; }
+  void    SetBeamMassNumberEast(const Short_t& bme) const          { AliFlowConstants::fgBeamMassNumberEast = bme; }
+  void    SetBeamMassNumberWest(const Short_t& bmw) const          { AliFlowConstants::fgBeamMassNumberWest = bmw; }
+
+// Fills Weights from Arrays (from file: flowPhiWgt.hist.root)
+  void    SetPhiWeight(const AliFlowConstants::PhiWgt_t& pPhiWgt)          { memcpy (fPhiWgt, pPhiWgt, sizeof(AliFlowConstants::PhiWgt_t)); }
+  void    SetPhiWeightPlus(const AliFlowConstants::PhiWgt_t& pPhiWgtPlus)   { memcpy (fPhiWgtPlus,  pPhiWgtPlus,  sizeof(AliFlowConstants::PhiWgt_t)); }
+  void    SetPhiWeightMinus(const AliFlowConstants::PhiWgt_t& pPhiWgtMinus) { memcpy (fPhiWgtMinus, pPhiWgtMinus, sizeof(AliFlowConstants::PhiWgt_t)); }
+  void    SetPhiWeightCross(const AliFlowConstants::PhiWgt_t& pPhiWgtCross) { memcpy (fPhiWgtCross, pPhiWgtCross, sizeof(AliFlowConstants::PhiWgt_t)); }
 
 
 private:
 
+ // to make the code checker happy
+  AliFlowEvent(const AliFlowEvent &flowEvent) ;                 // Copy Constructor (dummy)
+  AliFlowEvent &operator=(const AliFlowEvent &flowEvent) ;      // Assignment Operator (dummy)
+
  // Data Members
   Int_t               fEventID;                                  // ID of the event
   Int_t               fRunID;                                    // ID of the run
   UInt_t              fOrigMult;                                 // Original number of tracks
-  Long_t              fL0TriggerWord;                            // L0 trigger word
+  Long_t              fL0Trigger;                                // Level 0 trigger 
   Int_t               fZDCpart;                                  // ZDC estimated number of participants 
   Float_t             fZDCenergy[3];                             // ZDC reconstructed energy [neutron,proton,em]
   Float_t            fVertexPos[3];                             // primary vertex position
   Int_t               fCentrality;                               //! Centrality Class (calculated from mult.)
 
  // extension
-  //Float_t          fExtPsi[AliFlowConstants::kHars] ;                         // external RP angle (should be an input)
-  //Float_t          fExtRes[AliFlowConstants::kHars] ;                         // external RP resolution (should be an input as well)
+  Float_t            fExtPsi[AliFlowConstants::kHars] ;         // external RP angle (should be an input)
+  Float_t            fExtRes[AliFlowConstants::kHars] ;         // external RP resolution (should be an input as well)
 
  // Tracks & V0s
-  TObjArray*         fTrackCollection ;                         // collection of Flow Tracks
-  TObjArray*         fV0Collection ;                            // collection of Flow V0s
+  TClonesArray*              fTrackCollection ;                         // collection of Flow Tracks
+  TClonesArray*              fV0Collection ;                            // collection of Flow V0s
 
  // Weights
   AliFlowConstants::PhiWgt_t      fPhiWgt;                       //! flattening weights (single hist)
@@ -170,13 +168,12 @@ private:
   //Double_t           fBayesianCs[AliFlowConstants::kPid] ;    //! expected particles abundance (see Bayesian P.Id.)
 
  // Weighting & Settings
-  static Bool_t       fPtWgt;                                    //! flag for pt weighting
-  static Bool_t       fEtaWgt;                                   //! flag for eta weighting for odd harmonics
-  static Bool_t       fOnePhiWgt;                                //! flag for phi weights (just one hist)
-  static Bool_t       fNoWgt;                                           //! No Weights (Wgt == 1)
-  static Bool_t       fEtaSubs;                                  //! Flag for making Eta Subevents
+  static Bool_t       fgPtWgt;                                   //! flag for pt weighting
+  static Bool_t       fgEtaWgt;                                  //! flag for eta weighting for odd harmonics
+  static Bool_t       fgOnePhiWgt;                               //! flag for phi weights (just one hist)
+  static Bool_t       fgNoWgt;                                  //! No Weights (Wgt == 1)
+  static Bool_t       fgEtaSubs;                                 //! Flag for making Eta Subevents
 
-#ifndef __CINT__
  // shortcuts (to speed up the execution)
   Bool_t   fDone ;                                                                                     //! flag setted kTRUE when the loop is done
   TVector2 fQ[AliFlowConstants::kSels][AliFlowConstants::kHars];                                       //! flow vector
@@ -184,7 +181,6 @@ private:
   Float_t  fSumOfWeightSqr[AliFlowConstants::kSels][AliFlowConstants::kHars];                                  //! Sqrt(Sum(wgt)) ~ Sqrt(Mult)
   TVector2 fQSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];           //! flow vector subs
   UInt_t   fMultSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];        //! multiplicity subs
-#endif /*__CINT__*/
 
   ClassDef(AliFlowEvent,2) ;                    // macro for rootcint
 };
index b0f4a6383996ec6f813cb7bff2aa4b9d94f52778..59859df154be9b5c1a0e70ddc7c7644d7313baec 100644 (file)
@@ -22,6 +22,8 @@
 #include <TROOT.h>
 #include <TFile.h>
 #include <TString.h>
+#include <TMath.h>
+#include "TClonesArray.h"
 
 // AliRoot things
 #include "AliESD.h"
@@ -98,7 +100,8 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
  //cout << " -evt- " << fFlowEvent << endl ;
 
  fRunID = fESD->GetRunNumber() ;
- fEventNumber = fESD->GetEventNumber() ;
+ fEventNumber = -1 ;
+ // fEventNumber = fESD->GetEventNumber() ;
  fNumberOfTracks = fESD->GetNumberOfTracks() ;
  fNumberOfV0s = fESD->GetNumberOfV0s() ;
  //
@@ -112,9 +115,9 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
  // Run information (fixed - ???)
  fMagField = fESD->GetMagneticField() ; // cout << " *fMagField " << fMagField << endl ;
  fFlowEvent->SetMagneticField(fMagField) ;     
- fFlowEvent->SetCenterOfMassEnergy(AliFlowConstants::fgCenterOfMassEnergy) ;   
- fFlowEvent->SetBeamMassNumberEast(AliFlowConstants::fgBeamMassNumberEast) ;   
- fFlowEvent->SetBeamMassNumberWest(AliFlowConstants::fgBeamMassNumberWest) ;   
+ fFlowEvent->SetCenterOfMassEnergy(AliFlowConstants::fgCenterOfMassEnergy) ;  
+ fFlowEvent->SetBeamMassNumberEast(AliFlowConstants::fgBeamMassNumberEast) ;  
+ fFlowEvent->SetBeamMassNumberWest(AliFlowConstants::fgBeamMassNumberWest) ;  
 
  // Trigger information (now is: ULon64_t - some trigger mask)
  fFlowEvent->SetL0TriggerWord((Int_t)fESD->GetTriggerMask()); 
@@ -137,20 +140,19 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
  // Track loop
  if(fLoopTrks)
  {
-  Int_t badTrks = 0 ;
+  Int_t badTrks = 0 ;   
   for(fTrackNumber=0;fTrackNumber<fNumberOfTracks;fTrackNumber++) 
   {
    fTrack = fESD->GetTrack(fTrackNumber) ;
    if(CheckTrack(fTrack))
    {
-    fFlowTrack = FillFlowTrack(fTrack) ;   
-    fFlowEvent->TrackCollection()->Add(fFlowTrack) ;   
+    FillFlowTrack(fTrack) ;   
     fGoodTracks++ ;                                  
    }
    else { badTrks++ ; continue ; }
   }
   fCutTrks += badTrks ;
- }
+ } // cout << " -track number- :  " << fTrackNumber << endl ;
 
  // V0 loop
  if(fLoopV0s)
@@ -161,14 +163,13 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
    fV0 = fESD->GetV0(fV0Number) ;                      
    if(CheckV0(fV0))
    {
-    fFlowV0 =  FillFlowV0(fV0) ;
-    fFlowEvent->V0Collection()->Add(fFlowV0) ;
+    FillFlowV0(fV0) ;
     fGoodV0s++ ;                       
    }
    else { badV0s++ ; continue ; }
   }
   fCutV0s += badV0s ;
- }
+ } // cout << " -v0 number- :  " << fV0Number << endl ;
 
  // Evt setting stuff
  fFlowEvent->SetCentrality();  
@@ -182,9 +183,12 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  // From the AliESDtrack (input) fills the AliFlowTrack (output) .
 
  TString name = "" ; name += fTrackNumber ;
- fFlowTrack = new AliFlowTrack(name.Data()) ;
- //cout << " -tr- " << name.Data() << endl ;
+ Int_t idx = fFlowEvent->TrackCollection()->GetEntries() ;
+ fFlowTrack = (AliFlowTrack*)(fFlowEvent->TrackCollection()->New(idx)) ;
+ fFlowTrack->SetName(name.Data()) ;
  
+ // cout << " -tr- " << name.Data() << "(" << idx << ")"  << endl ;
+
  // ESD particle label (link: KineTree-ESD)
  Int_t label = TMath::Abs(fTrack->GetLabel());
  fFlowTrack->SetLabel(label) ;                         
@@ -194,6 +198,12 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  fTrack->GetImpactParameters(xy,z) ; 
  fFlowTrack->SetDcaSigned(xy,z) ;                  
 
+ // error on the DCA
+ Float_t dcaBis[2] ; Float_t dcaCov[3] ; 
+ for(Int_t dd=0;dd<3;dd++) { dcaCov[dd] = 0. ; }
+ fTrack->GetImpactParameters(dcaBis, dcaCov) ;
+ fFlowTrack->SetDcaError(dcaCov[0],dcaCov[1],dcaCov[2]) ;                  
+
  // UnConstrained (global) first
  Double_t gD[3] ;                              
  fTrack->GetPxPyPz(gD) ;                       
@@ -201,7 +211,7 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  Float_t phiGl = (Float_t)Phi(gD) ;  
  if(phiGl<0) { phiGl += 2*TMath::Pi() ; }
  fFlowTrack->SetPhiGlobal(phiGl) ;             
- Float_t ptGl = (Float_t)Pt(gD) ; 
+ Float_t ptGl = (Float_t)Pt(gD) ;  if(ptGl<=0) { cout << " !!! ptGlobal = " << ptGl << endl ; }
  fFlowTrack->SetPtGlobal(ptGl) ;               
  Float_t etaGl = (Float_t)Eta(gD) ; 
  fFlowTrack->SetEtaGlobal(etaGl) ;             
@@ -220,7 +230,7 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
   Float_t phi = (Float_t)Phi(cD) ; 
   if(phi<0) { phi += 2*TMath::Pi() ; }
   fFlowTrack->SetPhi(phi) ;                            
-  Float_t pt = (Float_t)Pt(cD) ; 
+  Float_t pt = (Float_t)Pt(cD) ;   if(pt<=0) { cout << " !!! pt = " << pt << endl ; }
   fFlowTrack->SetPt(pt) ;                              
   Float_t eta = (Float_t)Eta(cD) ; 
   fFlowTrack->SetEta(eta) ;                            
@@ -358,10 +368,18 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  // From the AliESDv0 (input) fills the AliFlowV0 (output) .
 
  TString name = "" ; name += fV0Number ;
- fFlowV0 = new AliFlowV0(name.Data()) ;
- //cout << " -v0- " << name.Data() << endl ;
+ Int_t idx = fFlowEvent->V0Collection()->GetEntries() ;
+ fFlowV0 = (AliFlowV0*)(fFlowEvent->V0Collection()->New(idx)) ;
+ fFlowV0->SetName(name.Data()) ;
+ // cout << " -v0- " << name.Data() << "(" << idx << ")"  << endl ;
+
+ // ESD particle label (link: KineTree-ESD)
+ Int_t label = -1 ; // TMath::Abs(fV0->GetLabel());
+ fFlowV0->SetLabel(label) ;                    
 
- Double_t pxyz[3] ;            // reconstructed momentum of the V0
+ // reconstructed momentum of the V0
+ Double_t pxyz[3] ;
  fV0->GetPxPyPz(pxyz[0],pxyz[1],pxyz[2]) ;
 
  Float_t phi = (Float_t)Phi(pxyz) ; if(phi<0) { phi += 2*TMath::Pi() ; }
@@ -371,19 +389,24 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  Float_t eta = (Float_t)Eta(pxyz) ; 
  fFlowV0->SetEta(eta) ;        
 
- Double_t xyz[3] ;             // reconstructed position of the V0 
+ // reconstructed position of the V0 
+ Double_t xyz[3] ;             
  fV0->GetXYZ(xyz[0],xyz[1],xyz[2]) ;           
  fFlowV0->SetCrossPoint(xyz[0],xyz[1],xyz[2]) ;
 
- // // V0's impact parameter & error (chi2 , DCA , sigma)  
- // fFlowV0->SetDca((Float_t)fV0->GetDistNorm()) ;    // GetD()  
- // fFlowV0->SetSigma((Float_t)fV0->GetDistSigma()) ;
- // fFlowV0->SetChi2((Float_t)fV0->GetChi2V0()) ;     // AliRoot v4-04-Release (December 2006) 
- // fFlowV0->SetChi2((Float_t)fV0->GetChi2()) ;              // AliRoot v4-04-Release (old)
- // // ...when they'll stop changing the methods I may enable the above lines. For now:
+ // V0's impact parameter & error (chi2 , DCA , sigma , pointing angle)  
+ //fFlowV0->SetDca((Float_t)fV0->GetD()) ;    // GetDistNorm 
+ //fFlowV0->SetSigma((Float_t)fV0->GetDistSigma()) ;
+ //fFlowV0->SetCosPointingAngle((Float_t)fV0->GetV0CosineOfPointingAngle()) ;  
+ //fFlowV0->SetDaughtersDCA(fV0->GetDcaV0Daughters()) ;
+ //fFlowV0->SetChi2((Float_t)fV0->GetChi2V0()) ;     // AliRoot v4-04-Release (December 2006)  
+ //fFlowV0->SetChi2((Float_t)fV0->GetChi2()) ;       // AliRoot v4-04-Release (old)
+ // ...when they'll stop changing the methods I'll enable the above lines. For now:
+ fFlowV0->SetDca(0.);
+ fFlowV0->SetSigma(0.1); 
+ fFlowV0->SetCosPointingAngle(1.) ;    
+ fFlowV0->SetDaughtersDca(0.) ;
  fFlowV0->SetChi2(1.) ;
- fFlowV0->SetDca(1.);      // GetD()
- fFlowV0->SetSigma(1.); 
 
  // P.id. 
  Int_t pdgCode = fV0->GetPdgCode() ;
@@ -392,6 +415,7 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  // mass 
  fFlowV0->SetVmass((Float_t)fV0->GetEffMass()) ; 
  
+ // daughters 
  Int_t pN = fV0->GetPindex() ;
  Int_t nN = fV0->GetNindex() ;
  AliFlowTrack* pos = (AliFlowTrack*)fFlowEvent->TrackCollection()->At(pN) ; 
index 4177c4cba599c1c2f1c0476cc00f1577492e060c..2edba63b0ec416cec9bfb15126cf1a7fc402eb60 100644 (file)
@@ -7,8 +7,8 @@
 //////////////////////////////////////////////////////////////////////
 //
 // Description: parser class from AliESD to AliFlowEvent . 
-//  nothing else to say, but those 3 lines need to be filled somehow,
-//  I hope now is ok!
+//  Nothing else to say at thispoint, but 3 lines of comments must be 
+//  there to make the code checker happy. I hope now is ok!
 //
 //////////////////////////////////////////////////////////////////////
 
@@ -18,6 +18,7 @@
 class AliFlowEvent ;
 class AliFlowTrack ;
 class AliFlowV0 ;
+class TClonesArray ;
 
 class AliESD ;
 class AliESDVertex ;
@@ -89,8 +90,9 @@ class AliFlowMaker  {
 
  private:
 
-   //AliFlowMaker(const AliFlowMaker &flowMak)                     { flowMak.fCounter ; } // Copy Constructor (dummy)
-   //AliFlowMaker &operator=(const AliFlowMaker &flowMak)   { return *this ; }   // Assignment Operator
+  // to make the code checker happy
+   AliFlowMaker(const AliFlowMaker &flowMak) ;                     // Copy Constructor (dummy)
+   AliFlowMaker &operator=(const AliFlowMaker &flowMak) ;   // Assignment Operator (dummy)
 
   // ESDs
     AliESD*          fESD;                                 //! "ESD" branch in fChain
index f56c97a264c4ce0f131edd12ac547861fb11fcf1..520900d74120563fad4b193159b2631249c89297 100644 (file)
@@ -76,6 +76,8 @@ AliFlowSelection::AliFlowSelection()
  fChiSqPart[1]         = 0 ;           // = 100.
  fDcaGlobalPart[0]     = 1 ;           // = 0.  
  fDcaGlobalPart[1]     = 0 ;           // = 1.  
+ fDcaOverSigma[0]      = 1 ;           // = 0. ;
+ fDcaOverSigma[1]      = 0 ;           // = 1. ;
  fYPart[0]            = 1 ;            // = 0.  
  fYPart[1]            = 0 ;            // = 0.  
  // -
@@ -166,51 +168,56 @@ Bool_t AliFlowSelection::SelectPart(AliFlowTrack* pFlowTrack) const
  
  // PID probability
  float pidProb = pFlowTrack->MostLikelihoodProb() ;
- if (fPidProbPart[1] > fPidProbPart[0] &&  (pidProb < fPidProbPart[0] || pidProb > fPidProbPart[1])) return kFALSE;
+ if(fPidProbPart[1] > fPidProbPart[0] &&  (pidProb < fPidProbPart[0] || pidProb > fPidProbPart[1])) return kFALSE;
  
  // Constrainable
  bool constrainable = pFlowTrack->IsConstrainable() ;
- if (fConstrainablePart && !constrainable)  return kFALSE;
+ if(fConstrainablePart && !constrainable)  return kFALSE;
  
  // Pt
  float pt = pFlowTrack->Pt();
- if (fPtPart[1] > fPtPart[0] &&  (pt < fPtPart[0] || pt > fPtPart[1])) return kFALSE;
+ if(fPtPart[1] > fPtPart[0] &&  (pt < fPtPart[0] || pt > fPtPart[1])) return kFALSE;
  
  // P
  float totalp = pFlowTrack->P();
- if (fPPart[1] > fPPart[0] && (totalp < fPPart[0] || totalp > fPPart[1])) return kFALSE;
+ if(fPPart[1] > fPPart[0] && (totalp < fPPart[0] || totalp > fPPart[1])) return kFALSE;
  
  // Eta
  float eta = pFlowTrack->Eta();
- if (fEtaPart[1] > fEtaPart[0] && (eta < fEtaPart[0] || eta > fEtaPart[1])) return kFALSE;
+ if(fEtaPart[1] > fEtaPart[0] && (eta < fEtaPart[0] || eta > fEtaPart[1])) return kFALSE;
  
  // |Eta|
  float absEta = TMath::Abs(pFlowTrack->Eta());
- if (fEtaAbsPart[1] > fEtaAbsPart[0] && (absEta < fEtaAbsPart[0] || absEta > fEtaAbsPart[1])) return kFALSE;
+ if(fEtaAbsPart[1] > fEtaAbsPart[0] && (absEta < fEtaAbsPart[0] || absEta > fEtaAbsPart[1])) return kFALSE;
  
  // Fit Points (TPC)
  int fitPts = pFlowTrack->FitPtsTPC();
- if (fFitPtsPart[1] > fFitPtsPart[0] && (fitPts < fFitPtsPart[0] || fitPts > fFitPtsPart[1])) return kFALSE;
+ if(fFitPtsPart[1] > fFitPtsPart[0] && (fitPts < fFitPtsPart[0] || fitPts > fFitPtsPart[1])) return kFALSE;
  
  // Fit Points over Max Points (TPC)
  int maxPts = pFlowTrack->MaxPtsTPC();
  if(maxPts) 
  { 
   float fitOverMaxPts = (float)(fitPts)/(float)maxPts ;
-  if (fFitOverMaxPtsPart[1] > fFitOverMaxPtsPart[0] && (fitOverMaxPts < fFitOverMaxPtsPart[0] || fitOverMaxPts > fFitOverMaxPtsPart[1])) return kFALSE;
+  if(fFitOverMaxPtsPart[1] > fFitOverMaxPtsPart[0] && (fitOverMaxPts < fFitOverMaxPtsPart[0] || fitOverMaxPts > fFitOverMaxPtsPart[1])) return kFALSE;
  }
  
  // Chi Squared (main Vertex)
  float chiSq = pFlowTrack->Chi2();
- if (fChiSqPart[1] > fChiSqPart[0] && (chiSq < fChiSqPart[0] || chiSq > fChiSqPart[1])) return kFALSE;
+ if(fChiSqPart[1] > fChiSqPart[0] && (chiSq < fChiSqPart[0] || chiSq > fChiSqPart[1])) return kFALSE;
  
  // DCA Global
  float globdca = pFlowTrack->Dca();
- if (fDcaGlobalPart[1] > fDcaGlobalPart[0] && (globdca < fDcaGlobalPart[0] || globdca > fDcaGlobalPart[1])) return kFALSE;
+ if(fDcaGlobalPart[1] > fDcaGlobalPart[0] && (globdca < fDcaGlobalPart[0] || globdca > fDcaGlobalPart[1])) return kFALSE;
+ // DCA Global
+ float dcaSigma = 1. ;
+ if(pFlowTrack->TransDcaError() != 0) { dcaSigma = pFlowTrack->TransDca() / pFlowTrack->TransDcaError() ; }
+ if(fDcaOverSigma[1] > fDcaOverSigma[0] && (dcaSigma < fDcaOverSigma[0] || dcaSigma > fDcaOverSigma[1])) return kFALSE;
 
  // Rapidity
  float y = pFlowTrack->Y();
- if (fYPart[1] > fYPart[0] && (y < fYPart[0] || y > fYPart[1])) return kFALSE;
+ if(fYPart[1] > fYPart[0] && (y < fYPart[0] || y > fYPart[1])) return kFALSE;
 
  return kTRUE;
 }
@@ -247,43 +254,43 @@ Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0) const
 
  // Pt
  float pt = pFlowV0->Pt();
- if (fV0Pt[1] > fV0Pt[0] &&  (pt < fV0Pt[0] || pt > fV0Pt[1])) return kFALSE;
+ if(fV0Pt[1] > fV0Pt[0] &&  (pt < fV0Pt[0] || pt > fV0Pt[1])) return kFALSE;
 
  // P
  float totalp = pFlowV0->P();
- if (fV0P[1] > fV0P[0] && (totalp < fV0P[0] || totalp > fV0P[1])) return kFALSE;
+ if(fV0P[1] > fV0P[0] && (totalp < fV0P[0] || totalp > fV0P[1])) return kFALSE;
 
  // Eta
  float eta = pFlowV0->Eta();
- if (fV0Eta[1] > fV0Eta[0] && (eta < fV0Eta[0] || eta > fV0Eta[1])) return kFALSE;
+ if(fV0Eta[1] > fV0Eta[0] && (eta < fV0Eta[0] || eta > fV0Eta[1])) return kFALSE;
  
  // |Eta|
  float absEta = TMath::Abs(pFlowV0->Eta());
- if (fV0EtaAbs[1] > fV0EtaAbs[0] && (absEta < fV0EtaAbs[0] || absEta > fV0EtaAbs[1])) return kFALSE;
+ if(fV0EtaAbs[1] > fV0EtaAbs[0] && (absEta < fV0EtaAbs[0] || absEta > fV0EtaAbs[1])) return kFALSE;
  
  // Chi Squared (main Vertex)
  float chiSq = pFlowV0->Chi2();
- if (fV0ChiSq[1] > fV0ChiSq[0] && (chiSq < fV0ChiSq[0] || chiSq > fV0ChiSq[1])) return kFALSE;
+ if(fV0ChiSq[1] > fV0ChiSq[0] && (chiSq < fV0ChiSq[0] || chiSq > fV0ChiSq[1])) return kFALSE;
 
  // DCA Cross
- float cdca = pFlowV0->CrossDca() ;
- if (fV0DcaCross[1] > fV0DcaCross[0] && (cdca < fV0DcaCross[0] || cdca > fV0DcaCross[1])) return kFALSE;
+ float cdca = pFlowV0->DaughtersDca() ;
+ if(fV0DcaCross[1] > fV0DcaCross[0] && (cdca < fV0DcaCross[0] || cdca > fV0DcaCross[1])) return kFALSE;
 
  // V0 lenght
  float lenght = pFlowV0->V0Lenght() ;
- if (fV0Lenght[1] > fV0Lenght[0] && (lenght < fV0Lenght[0] || lenght > fV0Lenght[1])) return kFALSE;
+ if(fV0Lenght[1] > fV0Lenght[0] && (lenght < fV0Lenght[0] || lenght > fV0Lenght[1])) return kFALSE;
 
  // V0 lenght
  float sigma  = pFlowV0->Sigma() ;
  if(sigma) 
  {
   float lenghtOverSigma = lenght/sigma ;
-  if (fV0LenghtOverSigma[1] > fV0LenghtOverSigma[0] && (lenghtOverSigma < fV0LenghtOverSigma[0] || lenghtOverSigma > fV0LenghtOverSigma[1])) return kFALSE;
+  if(fV0LenghtOverSigma[1] > fV0LenghtOverSigma[0] && (lenghtOverSigma < fV0LenghtOverSigma[0] || lenghtOverSigma > fV0LenghtOverSigma[1])) return kFALSE;
  }
 
  // Rapidity
  float y = pFlowV0->Y();
- if (fV0Y[1] > fV0Y[0] && (y < fV0Y[0] || y > fV0Y[1])) return kFALSE;
+ if(fV0Y[1] > fV0Y[0] && (y < fV0Y[0] || y > fV0Y[1])) return kFALSE;
 
  return kTRUE;
 }
@@ -342,27 +349,29 @@ void AliFlowSelection::PrintList() const
  cout << "# Selection List (particles correlated to the event plane):" << endl;
  cout << "# " << endl;
  if(fPidPart[0]!='\0') 
- { cout << "# P.id for particles correlated to the event plane: " << fPidPart << "  " <<endl ; }
+ { cout << "# P.id for particles correlated to the event plane: " << fPidPart << "  " << endl ; }
  if(fPtPart[1]>fPtPart[0]) 
- { cout << "# Pt for particles correlated to the event plane: " << fPtPart[0] << " to " << fPtPart[1] << " GeV/c" <<endl ; }
+ { cout << "# Pt for particles correlated to the event plane: " << fPtPart[0] << " to " << fPtPart[1] << " GeV/c" << endl ; }
  if(fPPart[1]>fPPart[0]) 
- { cout << "# P for particles correlated to the event plane: " << fPPart[0] << " to " << fPPart[1] << " GeV/c" <<endl ; }
+ { cout << "# P for particles correlated to the event plane: " << fPPart[0] << " to " << fPPart[1] << " GeV/c" << endl ; }
  if(fEtaPart[1]>fEtaPart[0]) 
- { cout << "# Eta for particles correlated to the event plane: " << fEtaPart[0] << " to " << fEtaPart[1] <<endl ; }
+ { cout << "# Eta for particles correlated to the event plane: " << fEtaPart[0] << " to " << fEtaPart[1] << endl ; }
  if(fEtaAbsPart[1]>fEtaAbsPart[0]) 
- { cout << "# |Eta| for V0s correlated to the event plane: " << fEtaAbsPart[0] << " to " << fEtaAbsPart[1] <<endl ; }
+ { cout << "# |Eta| for V0s correlated to the event plane: " << fEtaAbsPart[0] << " to " << fEtaAbsPart[1] << endl ; }
  if(fYPart[1]>fYPart[0]) 
- { cout << "# Y for particles correlated to the event plane: " << fYPart[0] << " to " << fYPart[1] <<endl ; }
+ { cout << "# Y for particles correlated to the event plane: " << fYPart[0] << " to " << fYPart[1] << endl ; }
  if(fFitPtsPart[1]>fFitPtsPart[0]) 
- { cout << "# Fit Points for particles correlated to the event plane: " << fFitPtsPart[0] << " to " << fFitPtsPart[1] <<endl ; }
+ { cout << "# Fit Points for particles correlated to the event plane: " << fFitPtsPart[0] << " to " << fFitPtsPart[1] << endl ; }
  if(fDedxPtsPart[1]>fDedxPtsPart[0]) 
  { cout << "# Dedx Points for particles correlated to the event plane: " << fDedxPtsPart[0] << " to " << fDedxPtsPart[1] << endl ; }
  if(fFitOverMaxPtsPart[1]>fFitOverMaxPtsPart[0]) 
- { cout << "# Fit/Max Points for particles correlated to the event plane: " << fFitOverMaxPtsPart[0] << " to " << fFitOverMaxPtsPart[1] <<endl ; }
+ { cout << "# Fit/Max Points for particles correlated to the event plane: " << fFitOverMaxPtsPart[0] << " to " << fFitOverMaxPtsPart[1] << endl ; }
  if(fChiSqPart[1]>fChiSqPart[0]) 
- { cout << "# Chi2 for particles correlated to the event plane: " << fChiSqPart[0] << " to " << fChiSqPart[1] <<endl ; }
+ { cout << "# Chi2 for particles correlated to the event plane: " << fChiSqPart[0] << " to " << fChiSqPart[1] << endl ; }
  if(fDcaGlobalPart[1]>fDcaGlobalPart[0]) 
- { cout << "# Global Dca for particles correlated with the event plane: " << fDcaGlobalPart[0] << " to " << fDcaGlobalPart[1] <<endl ; }
+ { cout << "# Global Dca for particles correlated with the event plane: " << fDcaGlobalPart[0] << " to " << fDcaGlobalPart[1] << endl ; }
+ if(fDcaOverSigma[1]>fDcaOverSigma[0])
+ { cout << "# Transverse Dca / Sigma for particles correlated with the event plane: " << fDcaOverSigma[0] << " to " << fDcaOverSigma[1] << endl ; }
  if(fConstrainablePart)         { cout << "# Constrainability cut:   Constrained  Tracks " << endl ; }
  cout << "#################################################################" << endl;
 }
@@ -375,7 +384,7 @@ void AliFlowSelection::PrintV0List() const
  cout << "# Selection List (V0s correlated with the event plane):" << endl;
  cout << "# " << endl;
  if(fV0Pid[0]!='\0') 
- { cout << "# P.id for V0s correlated to the event plane: " << fV0Pid << "  " <<endl ; }
+ { cout << "# P.id for V0s correlated to the event plane: " << fV0Pid << "  " << endl ; }
  if(fV0Mass[1]>fV0Mass[0]) 
  {
   if(!fV0SideBand)
@@ -384,23 +393,23 @@ void AliFlowSelection::PrintV0List() const
   { cout << "# Invariant Mass for V0-SideBands correlated to the event plane: " << fV0Mass[0]-fV0SideBand << " to " << fV0Mass[0]  << " & " << fV0Mass[1] << " to " << fV0Mass[1]+fV0SideBand << endl ; }
  }
  if(fV0Pt[1]>fV0Pt[0]) 
- { cout << "# Pt for V0s correlated to the event plane: " << fV0Pt[0] << " to " << fV0Pt[1] << " GeV/c" <<endl ; }
+ { cout << "# Pt for V0s correlated to the event plane: " << fV0Pt[0] << " to " << fV0Pt[1] << " GeV/c" << endl ; }
  if(fV0P[1]>fV0P[0]) 
- { cout << "# P for V0s correlated to the event plane: " << fV0P[0] << " to " << fV0P[1] << " GeV/c" <<endl ; }
+ { cout << "# P for V0s correlated to the event plane: " << fV0P[0] << " to " << fV0P[1] << " GeV/c" << endl ; }
  if(fV0Eta[1]>fV0Eta[0]) 
- { cout << "# Eta for V0s correlated to the event plane: " << fV0Eta[0] << " to " << fV0Eta[1] <<endl ; }
+ { cout << "# Eta for V0s correlated to the event plane: " << fV0Eta[0] << " to " << fV0Eta[1] << endl ; }
  if(fV0EtaAbs[1]>fV0EtaAbs[0]) 
- { cout << "# |Eta| for V0s correlated to the event plane: " << fV0EtaAbs[0] << " to " << fV0EtaAbs[1] <<endl ; }
+ { cout << "# |Eta| for V0s correlated to the event plane: " << fV0EtaAbs[0] << " to " << fV0EtaAbs[1] << endl ; }
  if(fV0Y[1]>fV0Y[0]) 
- { cout << "# Y for V0s correlated to the event plane: " << fV0Y[0] << " to " << fV0Y[1] <<endl ; }
+ { cout << "# Y for V0s correlated to the event plane: " << fV0Y[0] << " to " << fV0Y[1] << endl ; }
  if(fV0ChiSq[1]>fV0ChiSq[0]) 
- { cout << "# Chi2 for V0s correlated to the event plane: " << fV0ChiSq[0] << " to " << fV0ChiSq[1] <<endl ; }
+ { cout << "# Chi2 for V0s correlated to the event plane: " << fV0ChiSq[0] << " to " << fV0ChiSq[1] << endl ; }
  if(fV0DcaCross[1]>fV0DcaCross[0]) 
- { cout << "# Closest approach between the daughter tracks for V0s correlated to the event plane: " << fV0DcaCross[0] << " to " << fV0DcaCross[1] <<endl ; }
+ { cout << "# Closest approach between the daughter tracks for V0s correlated to the event plane: " << fV0DcaCross[0] << " to " << fV0DcaCross[1] << endl ; }
  if(fV0Lenght[1]>fV0Lenght[0]) 
- { cout << "# ... for V0s correlated to the event plane: " << fV0Lenght[0] << " to " << fV0Lenght[1] <<endl ; }
+ { cout << "# ... for V0s correlated to the event plane: " << fV0Lenght[0] << " to " << fV0Lenght[1] << endl ; }
  if(fV0LenghtOverSigma[1]>fV0LenghtOverSigma[0]) 
- { cout << "# ... for V0s correlated to the event plane: " << fV0LenghtOverSigma[0] << " to " << fV0LenghtOverSigma[1] <<endl ; }
+ { cout << "# ... for V0s correlated to the event plane: " << fV0LenghtOverSigma[0] << " to " << fV0LenghtOverSigma[1] << endl ; }
  cout << "#################################################################" << endl;
 }
 //-----------------------------------------------------------------------
@@ -449,7 +458,7 @@ void AliFlowSelection::SetHarmonic(const Int_t& harN)
 {
  // sets the Harmonic #
 
- if (harN < 0 || harN >= AliFlowConstants::kHars) 
+ if(harN < 0 || harN >= AliFlowConstants::kHars) 
  {
   cout << "### Harmonic " << harN << " not valid" << endl;
   fHarmonic = 0;
@@ -461,7 +470,7 @@ void AliFlowSelection::SetSelection(const Int_t& selN)
 {
  // sets the Selection #
 
- if (selN < 0 || selN >= AliFlowConstants::kSels) 
+ if(selN < 0 || selN >= AliFlowConstants::kSels) 
  {
   cout << "### Selection " << selN << " not valid" << endl;
   fSelection = 0;
@@ -473,7 +482,7 @@ void AliFlowSelection::SetSubevent(const Int_t& subN)
 {
  // sets the Sub-Event # (-1 for the full-event)
 
- if (subN < -1 || subN > AliFlowConstants::kSubs) 
+ if(subN < -1 || subN > AliFlowConstants::kSubs) 
  {
   cout << "### Subevent " << subN << " not valid" << endl;
   fSubevent = -1;
index f0dd95182c0ada807011d0ec1181373ef5b93aa1..45adf8b9c78f160a89fda9bb3a9522174b0842ed 100644 (file)
@@ -50,7 +50,7 @@ class AliFlowSelection : public TObject {
   Int_t   Har() const                                 { return fHarmonic; }                   // Returns the Selection
   Int_t   Sub() const                                 { return fSubevent; }                   // Returns the Sub-Event
 
- // Gets (R.P. cuts) and CutList
+ // Gets (R.P. cuts)
   Float_t EtaCutLo(Int_t harN, Int_t selN) const       { return fgEtaTpcCuts[0][harN][selN] ; } // Returns lower eta cut for R.P.[harN][selN] calculation (absolute values)
   Float_t EtaCutHi(Int_t harN, Int_t selN) const       { return fgEtaTpcCuts[1][harN][selN] ; } // Returns upper eta cut for R.P.[harN][selN] calculation (absolute values)
   Float_t PtCutLo(Int_t harN, Int_t selN) const        { return fgPtTpcCuts[0][harN][selN] ; }  // Returns lower pT cut for R.P.[harN][selN] calculation 
@@ -75,16 +75,16 @@ class AliFlowSelection : public TObject {
   void    PrintSelectionList() const ;                                                        // Prints a summary of the selection criteria (for RP determination)
   void    PrintV0List() const ;                                                                       // Prints the v0s cut-list (for correlation analysis)
 
- // Harmonic & Selection set (R.P.)
+ // Sets (Harmonic, Selection, Sub-event)
   void    SetHarmonic(const Int_t& harN);                                                             // Sets the Harmonic
   void    SetSelection(const Int_t& selN);                                                            // Sets the Selection
   void    SetSubevent(const Int_t& subN);                                                             // Sets the Sub-Event
   
- // Cuts set (Reaction Plane)
-  static void SetEtaCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN) { fgEtaTpcCuts[0][harN][selN] = lo ; fgEtaTpcCuts[1][harN][selN] = hi ; } // Sets the particle specie used in R.P. calculation
-  static void SetPtCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)  { fgPtTpcCuts[0][harN][selN] = lo  ; fgPtTpcCuts[1][harN][selN] = hi ; }  // Sets |eta| cut for R.P.[harN][selN] calculation
-  static void SetDcaGlobalCut(Float_t lo, Float_t hi)                  { fgDcaGlobalCuts[0] = lo ; fgDcaGlobalCuts[1] = hi ; }                   // Sets pT cut for R.P.[harN][selN] calculation
-  static void SetPidCut(const Char_t* pid)                             { strncpy(fgPid, pid, 9) ; fgPid[9] = '\0' ; }                            // Sets DCA cut for R.P. calculation
+ // Sets (R.P. cuts)
+  static void SetEtaCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN) { fgEtaTpcCuts[0][harN][selN] = lo ; fgEtaTpcCuts[1][harN][selN] = hi ; } // Sets |eta| cut for R.P.[harN][selN] calculation
+  static void SetPtCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)  { fgPtTpcCuts[0][harN][selN] = lo  ; fgPtTpcCuts[1][harN][selN] = hi ; }  // Sets pT cut for R.P.[harN][selN] calculation
+  static void SetDcaGlobalCut(Float_t lo, Float_t hi)                  { fgDcaGlobalCuts[0] = lo ; fgDcaGlobalCuts[1] = hi ; }                   // Sets DCA cut for R.P. calculation
+  static void SetPidCut(const Char_t* pid)                             { strncpy(fgPid, pid, 9) ; fgPid[9] = '\0' ; }                            // Sets the particle specie used in R.P. calculation
   static void SetConstrainCut(Bool_t tf = kTRUE)                       { fgConstrainable = tf ; }                                                // Sets the cut over un-constrainable tracks
   static void SetNhitsCut(Int_t hits,Int_t selN)                       { fgTPChits[selN] = hits; }                                               // Sets the minimum number of TPC hits for R.P.[selN] calculation
 
@@ -92,9 +92,7 @@ class AliFlowSelection : public TObject {
   void    SetCentralityCut(Int_t cent)                { fCent = cent ; }                      // Sets Event Centrality class
   void    SetRunIdCut(Int_t run)                      { fRun = run ; }                        // Sets Run number 
 
- // Cuts set (correlation analysis cuts of tracks & V0s)
-  void    SetPtBinsPart(Int_t bins)                   { fPtBinsPart = bins; }                                               // Sets N. of bins from fPtPart[0] to fPtPart[1]                
-
+ // Sets (Correlation analysis cuts of tracks & V0s)
   void    SetPidPart(const Char_t* pid)               { strncpy(fPidPart, pid, 9); fPidPart[9] = '\0'; }                    // Sets PID for particles wrt Reaction plane 
   void    SetPidProbPart(Float_t lo, Float_t hi)       { fPidProbPart[0] = lo ; fPidProbPart[1] = hi; }                     // Sets PID probability for particles wrt Reaction plane
   void    SetPtPart(Float_t lo, Float_t hi)           { fPtPart[0] = lo; fPtPart[1] = hi; }                                 // Sets pT for particles wrt Reaction plane 
@@ -107,8 +105,8 @@ class AliFlowSelection : public TObject {
   void    SetFitOverMaxPtsPart(Float_t lo, Float_t hi) { fFitOverMaxPtsPart[0] = lo; fFitOverMaxPtsPart[1] = hi; }          // Sets FitPoints/MaxPoints for particles wrt Reaction plane 
   void    SetChiSqPart(Float_t lo, Float_t hi)         { fChiSqPart[0] = lo; fChiSqPart[1] = hi; }                          // Sets Chi^2 for particles wrt Reaction plane          
   void    SetDcaGlobalPart(Float_t lo, Float_t hi)     { fDcaGlobalPart[0] = lo; fDcaGlobalPart[1] = hi; }                  // Sets d.c.a. for particles wrt Reaction plane         
-  void    SetConstrainablePart(Bool_t constr)         { fConstrainablePart = constr ; }                                     // Sets constrainability for particles wrt Reaction plane      
-
+  void    SetDcaOverSigma(Float_t lo, Float_t hi)      { fDcaOverSigma[0] = lo; fDcaOverSigma[1] = hi; }                    // Sets d.c.a. for particles wrt Reaction plane         
+  void    SetConstrainablePart(Bool_t constr)         { fConstrainablePart = constr ; }                                     // Sets constrainability for particles wrt Reaction plane
   void    SetV0Pid(const Char_t* pid)                 { strncpy(fV0Pid, pid, 9) ; fV0Pid[9] = '\0' ; }                      // Sets PID for v0 wrt plane (...)
   void    SetV0Mass(Float_t lo, Float_t hi)           { fV0Mass[0] = lo ; fV0Mass[1] = hi; }                                // Sets invariant mass cut for v0 wrt plane 
   void    SetV0Pt(Float_t lo, Float_t hi)             { fV0Pt[0] = lo ; fV0Pt[1] = hi; }                                    // Sets pT for v0 wrt plane 
@@ -123,6 +121,8 @@ class AliFlowSelection : public TObject {
   void    SetV0SideBands()                            { SetV0SideBands(TMath::Abs((fV0Mass[1]-fV0Mass[0])/2)) ; }           // Includes the v0 sideband analysis wrt plane          
   void    SetV0SideBands(Float_t sb)                  { fV0SideBand = sb ; }                                                // Includes the v0 sideband analysis and a width                
 
+  void    SetPtBinsPart(Int_t bins)                   { fPtBinsPart = bins; }                                               // Sets N. of bins from fPtPart[0] to fPtPart[1]                
+
 
  private:
 
@@ -164,6 +164,7 @@ class AliFlowSelection : public TObject {
   Float_t fFitOverMaxPtsPart[2];                               // FitPoints/MaxPoints for parts. wrt plane
   Float_t fChiSqPart[2];                                       // Chi^2 for parts. wrt plane
   Float_t fDcaGlobalPart[2];                                   // closest approach (to the main vertex) for parts. wrt plane
+  Float_t fDcaOverSigma[2];                                    // closest approach (to the main vertex) over its error
   Bool_t  fConstrainablePart;                                  // constrainability for parts. wrt plane 
 
  // Cuts for Tracks used in determining the Raction Plane (in STAR this selection was done inside the AliFlowEvent class)
@@ -171,7 +172,7 @@ class AliFlowSelection : public TObject {
   static Float_t  fgPtTpcCuts[2][AliFlowConstants::kHars][AliFlowConstants::kSels];    // pT range
   static Float_t  fgDcaGlobalCuts[2];                          // DCA cuts
   static Char_t   fgPid[10];                                   // h+, h-, pi-, pi+, pi, k+, k-, k, pr+, pr-, pr, e+, e-, e, d+, d-, d
-  static Int_t    fgTPChits[AliFlowConstants::kSels];                  // minimum number of TPC hits
+  static Int_t    fgTPChits[AliFlowConstants::kSels];          // minimum number of TPC hits
   static Bool_t   fgConstrainable;                             // cut un-constrainable tracks 
 
 
index 3adf20d53abc45de90df4aaa8d28d1465636c60d..0f96a4e39c6c537db7490120d28ec64d5e036040 100644 (file)
 
 #include "AliFlowTrack.h"
 #include "AliFlowConstants.h"
+
+#include "TMath.h"
 #include <iostream>
 using namespace std; //required for resolving the 'cout' symbol
 
-ClassImp(AliFlowTrack) 
-//////////////////////////////////////////////////////////////////////////////
+ClassImp(AliFlowTrack)
+//-------------------------------------------------------------
 AliFlowTrack::AliFlowTrack()
 {
  // Default constructor
@@ -51,8 +53,8 @@ AliFlowTrack::AliFlowTrack()
  fZLastPoint = 0. ;                          
  fTrackLength = 0. ;
  fMostLikelihoodPID = 0 ;                    
- for(Int_t ii=0;ii<2;ii++)         { fDcaSigned[ii] = 0 ; }                          
- for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fPidProb[ii] = 0. ; }
+ for(Int_t ii=0;ii<2;ii++)                     { fDcaSigned[ii] = 0. ; }                             
+ for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fPidProb[ii]   = 0. ; }
  for(Int_t ii=0;ii<4;ii++)
  {
   fFitPts[4]  = 0  ; fMaxPts[4]  = 0  ; 
@@ -61,7 +63,7 @@ AliFlowTrack::AliFlowTrack()
  }
  ResetSelection() ;                          
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 AliFlowTrack::AliFlowTrack(const Char_t* name) 
 {
  // TNamed constructor
@@ -69,73 +71,84 @@ AliFlowTrack::AliFlowTrack(const Char_t* name)
  SetName(name) ;
  AliFlowTrack() ;
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 AliFlowTrack::~AliFlowTrack() 
 {
  // default destructor (dummy)
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t  AliFlowTrack::P() const 
 { 
- // Returns the total momentum of the constrained track (calculated from Pt & Eta),
- // if the track is not constrainable returns 0 (used as flag for contrainable tracks).
+ // Returns the total momentum of the constrained track (calculated from Pt & Eta).
+ // If the track is not constrainable or eta is infinite, returns 0.
  
- if(!IsConstrainable()) { return 0 ; }               
- Float_t momentum = Pt()/TMath::Sqrt(1-(TMath::TanH(Eta())*TMath::TanH(Eta()))); 
+ if(!IsConstrainable()) { return 0. ; }                      
+
+ Float_t momentum = 0. ; 
+ Float_t conv = 1 - ( TMath::TanH(Eta()) * TMath::TanH(Eta()) ) ;
+ if(conv>0) { momentum = Pt() / TMath::Sqrt(conv) ; } 
+
  return momentum; 
 }
-//////////////////////////////////////////////////////////////////////////////
-Float_t  AliFlowTrack::PGlobal()                   const 
+//-------------------------------------------------------------
+Float_t  AliFlowTrack::PGlobal() const 
 { 
- // Returns the total momentum of the unconstrained track (always>0). 
+ // Returns the total momentum of the unconstrained track (calculated from PtGlobal & EtaGlobal). 
+ // If etaGlobal is infinite, returns 0.
+
+ Float_t momentum = 0. ; 
+ Float_t conv = 1 - ( TMath::TanH(EtaGlobal()) * TMath::TanH(EtaGlobal()) ) ;
+ if(conv>0) { momentum = PtGlobal() / TMath::Sqrt(conv) ; }
 
- Float_t momentum = PtGlobal()/TMath::Sqrt(1-(TMath::TanH(EtaGlobal())*TMath::TanH(EtaGlobal()))); 
  return momentum; 
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t  AliFlowTrack::Mass() const 
 { 
  // Returns the mass of the track, basing on its P.Id. hypotesis
 
- Float_t M = 0.13957 ;  // pion mass 
+ Float_t mass = 0.13957 ;  // pion mass 
 
- if(MostLikelihoodPID() == 0)                        { M = -1.    ; }
- else if(TMath::Abs(MostLikelihoodPID()) == 11)              { M = 0.00051; }
- else if(TMath::Abs(MostLikelihoodPID()) == 13)              { M = 0.10566; }
- else if(TMath::Abs(MostLikelihoodPID()) == 211)      { M = 0.49368; }
- else if(TMath::Abs(MostLikelihoodPID()) == 321)      { M = 0.13957; }
- else if(TMath::Abs(MostLikelihoodPID()) == 2212)     { M = 0.93827; }
- else if(TMath::Abs(MostLikelihoodPID()) == 10010020) { M = 1.87505; }
+ if(MostLikelihoodPID() == 0)                        { mass = -1.    ; }
+ else if(TMath::Abs(MostLikelihoodPID()) == 11)              { mass = 0.00051; }
+ else if(TMath::Abs(MostLikelihoodPID()) == 13)              { mass = 0.10566; }
+ else if(TMath::Abs(MostLikelihoodPID()) == 211)      { mass = 0.49368; }
+ else if(TMath::Abs(MostLikelihoodPID()) == 321)      { mass = 0.13957; }
+ else if(TMath::Abs(MostLikelihoodPID()) == 2212)     { mass = 0.93827; }
+ else if(TMath::Abs(MostLikelihoodPID()) == 10010020) { mass = 1.87505; }
 
- return M ;
+ return mass ;
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t  AliFlowTrack::InvMass() const 
 { 
  // Returns the invariant mass of the track, calculated from T.O.F. and P_tot
 
- Float_t M = -1 ;                  // if no calculation possible, it returns -1
+ Float_t mass = -1 ;               // if no calculation possible, it returns -1
  Float_t c = TMath::Ccgs()/1e+12 ;  // = 0.02998 ;  --> speed of light in cm/psec
  Float_t tof = TofTOF() ;          // in pico-seconds
  Float_t lenght = TrackLength() ;   // in cm
- Float_t Ptot = 0 ;                // constrained parameters are used if there, otherwise unconstrained
- if(IsConstrainable()) { Ptot = P() ; }
- else                  { Ptot = PGlobal() ; }
+ Float_t ptot = 0 ;                // constrained parameters are used if there, otherwise unconstrained
+ Float_t beta, gamma ;
+ if(IsConstrainable()) { ptot = P() ; }
+ else                  { ptot = PGlobal() ; }
  if(tof>0 && lenght>0)
- { 
-  Float_t beta = lenght / (tof * c) ;
+ {
+  beta = lenght / (tof * c) ;
   if(beta<1) 
   {
-   Float_t gamma = 1/TMath::Sqrt(1-(beta*beta)) ;
-   M = TMath::Abs(Ptot/(beta*gamma)) ;  
-  } // cout << ii << ": Mass = " << cmass << " , t/l = " << (tof/lenght) << " , beta = " << beta << " , gamma = " << gamma << endl ; }
- }  // else { cout << ii << ": TOF = " << tof << "     , Lenght = " << lenght << endl ; }
+   gamma = 1 / TMath::Sqrt( 1 - (beta * beta) ) ;
+   mass = TMath::Abs( ptot / (beta * gamma) ) ;  
+  }
+  //cout << " (yes) Mass = " << mass << " , t/l = " << (tof/lenght) << " , beta = " << beta << " , gamma = " << gamma << endl ; 
+ }   
+ //else { cout << " (no)  TOF = " << tof << "  , Lenght = " << lenght << endl ; }
 
- return M ;
+ return mass ;
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t  AliFlowTrack::Y() const 
 {
  // Rapidity of the constrained track.
@@ -145,15 +158,15 @@ Float_t  AliFlowTrack::Y() const
  if(TMath::Abs((Float_t)P()) == TMath::Abs((Float_t)Pt()))     { return 0. ; }
  else if(TMath::Abs((Float_t)P()) < TMath::Abs((Float_t)Pt())) { cout << "track: " << GetName() << "has  Pt() > P() !!!" << endl ; }
  // -
float M = Mass() ; 
double Pz = TMath::Sqrt(P()*P() - Pt()*Pt()); 
- if(Eta()<0) { Pz = -Pz ; }
double E = TMath::Sqrt(P()*P() + M*M) ;
float rapidity = 0.5*TMath::Log((E + Pz)/(E - Pz)) ;
Float_t mass = Mass() ; 
Double_t pz = TMath::Sqrt(P()*P() - Pt()*Pt()); 
+ if(Eta()<0) { pz = -pz ; }
Double_t e = TMath::Sqrt(P()*P() + mass*mass) ;
Float_t rapidity = 0.5*TMath::Log((e + pz)/(e - pz)) ;
  
  return rapidity ;
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t  AliFlowTrack::YGlobal() const 
 {
  // Rapidity of the unconstrained track
@@ -161,92 +174,40 @@ Float_t  AliFlowTrack::YGlobal() const
  if(TMath::Abs((Float_t)PGlobal()) == TMath::Abs((Float_t)PtGlobal()))            { return 0. ; }
  else if(TMath::Abs((Float_t)PGlobal()) < TMath::Abs((Float_t)PtGlobal())) { cout << "track: " << GetName() << "has  Pt() > P() !!!" << endl ; }
  // -
float M = Mass() ; 
double Pz = TMath::Sqrt(PGlobal()*PGlobal() - PtGlobal()*PtGlobal()); 
- if(EtaGlobal()<0) { Pz = -Pz ; }
double E = TMath::Sqrt(PGlobal()*PGlobal() + M*M) ;
float rapidity = 0.5*TMath::Log((E + Pz)/(E - Pz)) ;
Float_t mass = Mass() ; 
Double_t pz = TMath::Sqrt(PGlobal()*PGlobal() - PtGlobal()*PtGlobal()); 
+ if(EtaGlobal()<0) { pz = -pz ; }
Double_t e = TMath::Sqrt(PGlobal()*PGlobal() + mass*mass) ;
Float_t rapidity = 0.5*TMath::Log((e + pz)/(e - pz)) ;
  
  return rapidity ;
 }
-//////////////////////////////////////////////////////////////////////////////
-Bool_t AliFlowTrack::Select(Int_t harmonic,Int_t selection,Int_t subevent) const 
-{
- // Returns the selection flag for [harmonic] [selection] [sub-event]
-
- if((subevent == -1) || (subevent == fSubevent[harmonic][selection])) 
- {
-  if(fSelection[harmonic][selection]) { return kTRUE ; }
- } 
- return kFALSE ;       
-}
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::SetSelect(Int_t harmonic,Int_t selection) 
-{ 
- fSelection[harmonic][selection] = kTRUE ;
-}
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::SetSubevent(Int_t harmonic,Int_t selection,Int_t subevent) 
-{ 
- fSubevent[harmonic][selection] = subevent ; 
-}
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::PrintSelection() 
-{
- // Prints a short string of 0 & 1 to visualize the selections' flags
- // [har1][sel0],[har1][sel1],[har1][sel2],...,[har2][sel0],...
- for(int i=0;i<AliFlowConstants::kHars;i++)
- {
-  for(int j=0;j<AliFlowConstants::kSels;j++)
-  {
-   if(Select(i,j)) { cout << 1 ; }
-   else           { cout << 0 ; }
-  }
- }
- cout << endl ;
-}
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::ResetSelection() 
-{
- // Re-sets all the selection/sub-event flags to 0 
- // (track won't be used in any R.P. calculation)
-
- for(Int_t ii=0;ii<AliFlowConstants::kHars;ii++)
- {
-  for(Int_t jj=0;jj<AliFlowConstants::kSels;jj++)
-  {
-   fSelection[ii][jj] = kFALSE ; 
-   fSubevent[ii][jj] = -1 ; 
-  }
- }
-}
-//////////////////////////////////////////////////////////////////////////////
-const char* AliFlowTrack::Pid() const
+//-------------------------------------------------------------
+const Char_t* AliFlowTrack::Pid() const
 {
  // Returns the P.Id. in characters (e,mu,pi,k,p,d) basing on the stored pdg code 
  // and its sign (both stored in MostLikelihoodPID() ) .
  
- const char *name[] = {"e","mu","pi","k","pr","d"} ;
int pdg_code = TMath::Abs(MostLikelihoodPID()) ;
int charge = Charge() ;
+ const Char_t *name[] = {"e","mu","pi","k","pr","d"} ;
Int_t pdgCode = TMath::Abs(MostLikelihoodPID()) ;
Int_t charge = Charge() ;
 
- TString p_id = "" ;
- if(pdg_code == 11)            { p_id = name[0] ; }
- else if(pdg_code == 13)       { p_id = name[1] ; }
- else if(pdg_code == 211)      { p_id = name[2] ; }
- else if(pdg_code == 321)      { p_id = name[3] ; }
- else if(pdg_code == 2212)     { p_id = name[4] ; }
- else if(pdg_code == 10010020) { p_id = name[5] ; }
- else                         { p_id = "0" ; }
+ TString pId = "" ;
+ if(pdgCode == 11)            { pId = name[0] ; }
+ else if(pdgCode == 13)       { pId = name[1] ; }
+ else if(pdgCode == 211)      { pId = name[2] ; }
+ else if(pdgCode == 321)      { pId = name[3] ; }
+ else if(pdgCode == 2212)     { pId = name[4] ; }
+ else if(pdgCode == 10010020) { pId = name[5] ; }
+ else                        { pId = "0" ; }
 
- if(charge>0)          { p_id += "+" ; } 
- else if(charge<0)     { p_id += "-" ; }
- else                  { p_id += "" ; }
+ if(charge>0)                { pId += "+" ; } 
+ else if(charge<0)           { pId += "-" ; }
+ else                        { pId += "" ; }
  
- return p_id.Data() ; 
+ return pId.Data() ; 
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 void AliFlowTrack::PidProbs(Float_t pidN[AliFlowConstants::kPid]) const 
 { 
  // Returns the normalized probability for the given track to be [e,mu,pi,k,p,d] 
@@ -261,7 +222,7 @@ void AliFlowTrack::PidProbs(Float_t pidN[AliFlowConstants::kPid]) const
  }
  else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
 } 
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t  AliFlowTrack::PidProb(Int_t nn)       const
 {
  // Returns the normalized probability of the track to be [nn] (e,mu,pi,k,pi,d).
@@ -270,7 +231,7 @@ Float_t  AliFlowTrack::PidProb(Int_t nn)    const
  PidProbs(pidN) ;
  return pidN[nn] ;
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 TVector AliFlowTrack::PidProbs()               const
 {
  // Returns the normalized probability for the given track to be [e,mu,pi,k,p,d] 
@@ -283,29 +244,29 @@ TVector AliFlowTrack::PidProbs()                  const
 
  return pidNvec ;
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 void AliFlowTrack::RawPidProbs(Float_t pidV[AliFlowConstants::kPid]) const 
 { 
  // Returns the array of probabilities for the track to be [e,mu,pi,k,pi,d].
 
  for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { pidV[ii] = fPidProb[ii] ; }
 } 
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Float_t AliFlowTrack::MostLikelihoodProb()         const 
 { 
  // Returns the probability of the most probable P.id.
  // (Warning: THIS IS NOT WEIGHTED IN THE BAYESIAN WAY...) 
 
int pdg_code = TMath::Abs(MostLikelihoodPID()) ;
- if(pdg_code == 11)            { return fPidProb[0] ; }
- else if(pdg_code == 13)       { return fPidProb[1] ; }
- else if(pdg_code == 211)      { return fPidProb[2] ; }
- else if(pdg_code == 321)      { return fPidProb[3] ; }
- else if(pdg_code == 2212)     { return fPidProb[4] ; }
- else if(pdg_code == 10010020) { return fPidProb[5] ; }
Int_t pdgCode = TMath::Abs(MostLikelihoodPID()) ;
+ if(pdgCode == 11)            { return fPidProb[0] ; }
+ else if(pdgCode == 13)       { return fPidProb[1] ; }
+ else if(pdgCode == 211)      { return fPidProb[2] ; }
+ else if(pdgCode == 321)      { return fPidProb[3] ; }
+ else if(pdgCode == 2212)     { return fPidProb[4] ; }
+ else if(pdgCode == 10010020) { return fPidProb[5] ; }
  else { return 0. ; }
 } 
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 void AliFlowTrack::SetPid(const Char_t* pid)           
 { 
  // Sets the P.Id. hypotesis of the track from a String imput (that should be 
@@ -323,22 +284,7 @@ void AliFlowTrack::SetPid(const Char_t* pid)
  if(strchr(pid,'+'))      { fMostLikelihoodPID = TMath::Abs(fMostLikelihoodPID) * 1 ; }
  else if(strchr(pid,'-'))  { fMostLikelihoodPID = TMath::Abs(fMostLikelihoodPID) * -1 ; } 
 }
-//////////////////////////////////////////////////////////////////////////////
-Int_t AliFlowTrack::Charge() const 
-{ 
- // Tracks charge (stored as sign of fMostLikelihoodPID). +/-2 if deuterium.
- if(MostLikelihoodPID() == 10010020) { return TMath::Sign(2,MostLikelihoodPID()) ; }
- else                               { return TMath::Sign(1,MostLikelihoodPID()) ; }
-}            
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::SetCharge(Int_t charge)
-{ 
- // Sets the charge of the track (+/- sign of MostLikelihoodPID()).
- fMostLikelihoodPID = TMath::Sign(TMath::Abs(fMostLikelihoodPID),charge) ;
-}
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 Bool_t AliFlowTrack::IsConstrainable()             const 
 { 
  // Returns kTRUE if the track is constrainable. 
@@ -350,98 +296,82 @@ Bool_t AliFlowTrack::IsConstrainable()                const
  if(fPt==0 && fEta==0) { return kFALSE ; }
  else                 { return kTRUE ; }
 } 
-//////////////////////////////////////////////////////////////////////////////
-Float_t AliFlowTrack::Dca()                        const 
+//-------------------------------------------------------------
+Float_t AliFlowTrack::Dca() const 
 {
+ // distance of closest approach (norm(dca[2]))
+
  Double_t mag = 0 ;
  for(Int_t ii=0;ii<2;ii++) { mag += (fDcaSigned[ii]*fDcaSigned[ii]) ; } 
  return TMath::Sqrt(mag) ; 
 }     
-//////////////////////////////////////////////////////////////////////////////
-Float_t AliFlowTrack::Dca2(Float_t dca[2])         const 
-{ 
- Double_t mag = 0 ;
- for(Int_t ii=0;ii<2;ii++) 
- { 
-  dca[ii] = fDcaSigned[ii] ; 
-  mag += (fDcaSigned[ii]*fDcaSigned[ii]) ; 
- } 
- return TMath::Sqrt(mag) ; 
-}
-//////////////////////////////////////////////////////////////////////////////
-Float_t AliFlowTrack::Dca3(Float_t dca[3])         const 
+//-------------------------------------------------------------
+Float_t AliFlowTrack::DcaError() const 
 {
- dca[0] = TMath::Abs(fDcaSigned[0])* TMath::Cos(Phi()) ;
- dca[1] = TMath::Abs(fDcaSigned[0])* TMath::Sin(Phi()) ;
- dca[2] = TMath::Abs(fDcaSigned[1]) ;          
- return Dca() ; 
+ // error on the distance of closest approach
+
+ Double_t err = 0 ;
+ for(Int_t ii=0;ii<2;ii++) { err = (fDcaError[ii]*fDcaError[ii]) ; } 
+ return TMath::Sqrt(err) ; 
 }     
-//////////////////////////////////////////////////////////////////////////////
-Float_t  AliFlowTrack::Phi()                       const 
-{ 
- if(IsConstrainable()) { return fPhi ; }
- else          { return PhiGlobal() ; }
-}                  
-//////////////////////////////////////////////////////////////////////////////
-Float_t  AliFlowTrack::Pt()                        const 
-{  
- if(IsConstrainable())  { return fPt ; }
- else           { return PtGlobal() ; }
-}
-//////////////////////////////////////////////////////////////////////////////
-Float_t  AliFlowTrack::Eta()                       const 
-{  
- if(IsConstrainable())  { return fEta ; }
- else           { return EtaGlobal() ; }
-}                    
-//////////////////////////////////////////////////////////////////////////////
-Float_t  AliFlowTrack::PhiGlobal()                 const { return fPhiGlobal ; }                   
-Float_t  AliFlowTrack::PtGlobal()                  const { return fPtGlobal ; }                    
-Float_t  AliFlowTrack::EtaGlobal()                 const { return fEtaGlobal ; }                     
-//////////////////////////////////////////////////////////////////////////////
-Float_t AliFlowTrack::TransDcaSigned()                     const { return fDcaSigned[0] ; }            
-Float_t AliFlowTrack::TransDca()                   const { return TMath::Abs(TransDcaSigned()) ; }     
-Float_t  AliFlowTrack::Chi2()                      const { return fChi2 ; }                
-Float_t  AliFlowTrack::TrackLength()               const { return fTrackLength ; }         
-Float_t  AliFlowTrack::ZFirstPoint()               const { return fZFirstPoint ; }         
-Float_t  AliFlowTrack::ZLastPoint()                const { return fZLastPoint ; }          
+//-------------------------------------------------------------
+void AliFlowTrack::DcaError3(Float_t err[3]) const 
+{
+ // Dca Error (xy, z, cov(xy,z)) ...
 
-Int_t   AliFlowTrack::MostLikelihoodPID()          const { return fMostLikelihoodPID; } 
-Float_t  AliFlowTrack::ElectronPositronProb()      const { return PidProb(0) ; }
-Float_t  AliFlowTrack::MuonPlusMinusProb()         const { return PidProb(1) ; }
-Float_t  AliFlowTrack::PionPlusMinusProb()         const { return PidProb(2) ; }
-Float_t  AliFlowTrack::KaonPlusMinusProb()         const { return PidProb(3) ; }
-Float_t  AliFlowTrack::ProtonPbarProb()            const { return PidProb(4) ; }
-Float_t  AliFlowTrack::DeuteriumAntiDeuteriumProb() const { return PidProb(5) ; }
+ for(Int_t ii=0;ii<2;ii++) { err[ii] = TMath::Abs(fDcaError[ii]) ; }           
+}     
+//-------------------------------------------------------------
 
-Int_t   AliFlowTrack::FitPtsTPC()                  const { return fFitPts[0]  ; }  
-Int_t   AliFlowTrack::MaxPtsTPC()                  const { return fMaxPts[0]  ; }  
-Float_t  AliFlowTrack::Chi2TPC()                   const { return fFitChi2[0] ; }          
-Float_t  AliFlowTrack::DedxTPC()                   const { return fDedx[0]    ; }  
-Int_t   AliFlowTrack::FitPtsITS()                  const { return fFitPts[1]  ; }       
-Int_t   AliFlowTrack::MaxPtsITS()                  const { return fMaxPts[1]  ; }
-Float_t  AliFlowTrack::Chi2ITS()                   const { return fFitChi2[1] ; }               
-Float_t  AliFlowTrack::DedxITS()                   const { return fDedx[1]    ; }  
-Int_t   AliFlowTrack::NhitsTRD()                   const { return fFitPts[2]  ; }       
-Int_t   AliFlowTrack::MaxPtsTRD()                  const { return fMaxPts[2]  ; }  
-Float_t  AliFlowTrack::Chi2TRD()                   const { return fFitChi2[2] ; }               
-Float_t  AliFlowTrack::SigTRD()                            const { return fDedx[2]    ; }  
-Int_t   AliFlowTrack::NhitsTOF()                   const { return fFitPts[3]  ; }       
-Int_t   AliFlowTrack::MaxPtsTOF()                  const { return fMaxPts[3]  ; }  
-Float_t  AliFlowTrack::Chi2TOF()                   const { return fFitChi2[3] ; }               
-Float_t  AliFlowTrack::TofTOF()                            const { return fDedx[3]    ; }  
+//-------------------------------------------------------------
+Bool_t AliFlowTrack::Select(Int_t harmonic,Int_t selection,Int_t subevent) const 
+{
+ // Returns the selection flag for [harmonic] [selection] [sub-event]
 
-Float_t  AliFlowTrack::PatTPC()                    const { return fMom[0] ; }
-Float_t  AliFlowTrack::PatITS()                    const { return fMom[1] ; }
-Float_t  AliFlowTrack::PatTRD()                    const { return fMom[2] ; }
-Float_t  AliFlowTrack::PatTOF()                    const { return fMom[3] ; }
+ if((subevent == -1) || (subevent == fSubevent[harmonic][selection])) 
+ {
+  return fSelection[harmonic][selection] ; 
+ } 
+ return kFALSE ;       
+}
+//-------------------------------------------------------------
+void AliFlowTrack::PrintSelection() const
+{
+ // Prints a short string of 0 & 1 to visualize the selections' flags
+ // [har1][sel0],[har1][sel1],[har1][sel2],...,[har2][sel0],...
+ for(Int_t i=0;i<AliFlowConstants::kHars;i++)
+ {
+  for(Int_t j=0;j<AliFlowConstants::kSels;j++)
+  {
+   if(Select(i,j)) { cout << 1 ; }
+   else           { cout << 0 ; }
+  }
+ }
+ cout << endl ;
+}
+//-------------------------------------------------------------
+void AliFlowTrack::ResetSelection() 
+{
+ // Re-sets all the selection/sub-event flags to 0 
+ // (track won't be used in any R.P. calculation)
 
-Int_t    AliFlowTrack::Label()                     const { return fLabel ; }         
-//////////////////////////////////////////////////////////////////////////////
+ for(Int_t ii=0;ii<AliFlowConstants::kHars;ii++)
+ {
+  for(Int_t jj=0;jj<AliFlowConstants::kSels;jj++)
+  {
+   fSelection[ii][jj] = kFALSE ; 
+   fSubevent[ii][jj] = -1 ; 
+  }
+ }
+}
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
 void AliFlowTrack::SetConstrainable()                        
 { 
- // fills the constrained parameters with the unconstrained ones, making it
- // a constrainable track.                            !!! TRICKY METHOD !!!
+ // fills the constrained parameters with the unconstrained ones, making it a constrainable track.
+ //                                                   !!! TRICKY METHOD !!!
 
  if(!IsConstrainable()) 
  { 
@@ -450,7 +380,7 @@ void AliFlowTrack::SetConstrainable()
   fPt  = fPtGlobal ; 
  } 
 }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
 void AliFlowTrack::SetUnConstrainable()                              
 { 
  // deletes the constrained parameters making it  an unconstrainable track. 
@@ -463,49 +393,4 @@ void AliFlowTrack::SetUnConstrainable()
   fPt  = 0. ; 
  } 
 }
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::SetPhi(Float_t phi)                       { fPhi = phi; }
-void AliFlowTrack::SetEta(Float_t eta)                       { fEta = eta; }
-void AliFlowTrack::SetPt(Float_t pt)                         { fPt = pt; }
-void AliFlowTrack::SetPhiGlobal(Float_t phi)                 { fPhiGlobal = phi; }
-void AliFlowTrack::SetEtaGlobal(Float_t eta)                 { fEtaGlobal = eta; }
-void AliFlowTrack::SetPtGlobal(Float_t pt)                   { fPtGlobal = pt; }
-void AliFlowTrack::SetDcaSigned(Float_t xy, Float_t z)        { fDcaSigned[0] = xy ; fDcaSigned[1] = z ; }
-void AliFlowTrack::SetTransDcaSigned(Float_t xy)             { fDcaSigned[0] = xy ; }
-void AliFlowTrack::SetChi2(Float_t chi2)                     { fChi2 = chi2; }
-void AliFlowTrack::SetTrackLength(Float_t tl)                { fTrackLength = tl; }
-void AliFlowTrack::SetZFirstPoint(Float_t zFirst)            { fZFirstPoint = zFirst; }
-void AliFlowTrack::SetZLastPoint(Float_t zLast)              { fZLastPoint = zLast; }
-
-void AliFlowTrack::SetMostLikelihoodPID(Int_t val)            { fMostLikelihoodPID = val ; }   // feed here the Signed pdg_code 
-void AliFlowTrack::SetElectronPositronProb(Float_t val)       { fPidProb[0] = TMath::Abs(val) ; } 
-void AliFlowTrack::SetMuonPlusMinusProb(Float_t val)         { fPidProb[1] = TMath::Abs(val) ; } 
-void AliFlowTrack::SetPionPlusMinusProb(Float_t val)         { fPidProb[2] = TMath::Abs(val) ; } 
-void AliFlowTrack::SetKaonPlusMinusProb(Float_t val)         { fPidProb[3] = TMath::Abs(val) ; } 
-void AliFlowTrack::SetProtonPbarProb(Float_t val)            { fPidProb[4] = TMath::Abs(val) ; } 
-void AliFlowTrack::SetDeuteriumAntiDeuteriumProb(Float_t val) { fPidProb[5] = TMath::Abs(val) ; }
-
-void AliFlowTrack::SetFitPtsTPC(Int_t fitPts)                { fFitPts[0]  = fitPts ; }
-void AliFlowTrack::SetMaxPtsTPC(Int_t maxPts)                { fMaxPts[0]  = maxPts ; }
-void AliFlowTrack::SetChi2TPC(Float_t chi2)                  { fFitChi2[0] = chi2   ; }
-void AliFlowTrack::SetDedxTPC(Float_t dedx)                  { fDedx[0]    = dedx   ; }
-void AliFlowTrack::SetFitPtsITS(Int_t nhits)                 { fFitPts[1]  = nhits  ; }
-void AliFlowTrack::SetMaxPtsITS(Int_t maxPts)                { fMaxPts[1]  = maxPts ; }
-void AliFlowTrack::SetChi2ITS(Float_t chi2)                  { fFitChi2[1] = chi2   ; }
-void AliFlowTrack::SetDedxITS(Float_t dedx)                  { fDedx[1]    = dedx   ; }
-void AliFlowTrack::SetNhitsTRD(Int_t fitPts)                 { fFitPts[2]  = fitPts ; }
-void AliFlowTrack::SetMaxPtsTRD(Int_t maxPts)                { fMaxPts[2]  = maxPts ; }
-void AliFlowTrack::SetChi2TRD(Float_t chi2)                  { fFitChi2[2] = chi2   ; }
-void AliFlowTrack::SetSigTRD(Float_t dedx)                   { fDedx[2]    = dedx   ; }
-void AliFlowTrack::SetNhitsTOF(Int_t fitPts)                 { fFitPts[3]  = fitPts ; }
-void AliFlowTrack::SetMaxPtsTOF(Int_t maxPts)                { fMaxPts[3]  = maxPts ; }
-void AliFlowTrack::SetChi2TOF(Float_t chi2)                  { fFitChi2[3] = chi2   ; }
-void AliFlowTrack::SetTofTOF(Float_t dedx)                   { fDedx[3]    = dedx   ; }
-
-void AliFlowTrack::SetPatTPC(Float_t p)                      { fMom[0] = p ; }
-void AliFlowTrack::SetPatITS(Float_t p)                      { fMom[1] = p ; }
-void AliFlowTrack::SetPatTRD(Float_t p)                      { fMom[2] = p ; }
-void AliFlowTrack::SetPatTOF(Float_t p)                      { fMom[3] = p ; }
-
-void AliFlowTrack::SetLabel(Int_t label)                     { fLabel = label ; }
-//////////////////////////////////////////////////////////////////////////////
+//-------------------------------------------------------------
index 63459ffd01dcfcf88a82611162de8ea871f08c54..589a5ecab7546efc380be68586bcb29c57da0bac 100644 (file)
 //
 //////////////////////////////////////////////////////////////////////
 
-#ifndef ALIFLOWTRACK_h
-#define ALIFLOWTRACK_h
+#ifndef ALIFLOWTRACK_H
+#define ALIFLOWTRACK_H
 
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <iostream>
-#include <TROOT.h>
 #include "TMath.h"
-#include "TObject.h"
 #include "TNamed.h"
 #include "TString.h"
 #include "TVector.h"
@@ -37,126 +35,136 @@ public:
   virtual       ~AliFlowTrack();
 
  // Gets - Track variables
-  const Char_t* Pid()         const;
-  Int_t         Charge()      const;
-  Float_t       Mass()        const;
-  Float_t      InvMass()     const; 
-  Float_t       Phi()         const;
-  Float_t       Eta()         const;
-  Float_t       Pt()          const;
-  Float_t       P()           const;
-  Float_t       Y()           const;
-  Float_t       PhiGlobal()   const;
-  Float_t       EtaGlobal()   const;
-  Float_t       PtGlobal()    const;
-  Float_t       PGlobal()     const;
-  Float_t       YGlobal()     const;
-  Float_t       Chi2()        const;
-  Float_t       TrackLength() const;
-  Float_t       ZFirstPoint() const;
-  Float_t       ZLastPoint()  const;
-  Bool_t        IsConstrainable()    const;
-  Float_t       TransDcaSigned()     const;
-  Float_t       TransDca()    const;       
-  Float_t       Dca()        const;
-  Float_t      Dca2(Float_t dca[2]) const;
-  Float_t       Dca3(Float_t dca[3]) const;
-  Int_t         Label()                        const;
+  const Char_t* Pid()               const ;
+  Float_t       Mass()              const ;
+  Float_t      InvMass()            const ; 
+  Float_t       P()                 const ;
+  Float_t       Y()                 const ;
+  Float_t       PGlobal()           const ;
+  Float_t       YGlobal()           const ;
+  Bool_t        IsConstrainable()    const ;
+  Float_t       Dca()               const ;
+  Float_t       DcaError()          const ;
+  void          DcaError3(Float_t err[3]) const ;
+  Int_t         Charge()            const { return TMath::Sign(1,MostLikelihoodPID()) ; } 
+  Float_t       Phi()               const { if(IsConstrainable()) { return fPhi ; } else { return PhiGlobal() ; } }       
+  Float_t       Eta()               const { if(IsConstrainable()) { return fEta ; } else { return EtaGlobal() ; } }
+  Float_t       Pt()                const { if(IsConstrainable()) { return fPt  ; } else { return PtGlobal()  ; } }
+  Float_t       PhiGlobal()         const { return fPhiGlobal ; }
+  Float_t       EtaGlobal()         const { return fEtaGlobal ; }
+  Float_t       PtGlobal()          const { return fPtGlobal ; }
+  Float_t       Chi2()              const { return fChi2 ; }  
+  Float_t       TrackLength()       const { return fTrackLength ; }
+  Float_t       ZFirstPoint()       const { return fZFirstPoint ; }
+  Float_t       ZLastPoint()        const { return fZLastPoint ; }
+  Int_t         Label()             const { return fLabel ; }
+  Float_t       TransDcaSigned()     const { return fDcaSigned[0] ; }
+  Float_t       TransDca()          const { return TMath::Abs(fDcaSigned[0]) ; }  
+  Float_t       ZedDca()            const { return TMath::Abs(fDcaSigned[1]) ; }  
+  Float_t       TransDcaError()      const { return TMath::Abs(fDcaError[0]) ; }
+  Float_t       ZedDcaError()        const { return TMath::Abs(fDcaError[1]) ; }
+
  // Gets - P.id.
-  Int_t         MostLikelihoodPID()            const;
   Float_t       MostLikelihoodProb()           const;
-  Float_t       ElectronPositronProb()         const;
-  Float_t       MuonPlusMinusProb()            const;
-  Float_t       PionPlusMinusProb()            const;
-  Float_t       KaonPlusMinusProb()            const;
-  Float_t       ProtonPbarProb()               const;
-  Float_t       DeuteriumAntiDeuteriumProb()   const;
-  Float_t       PidProb(Int_t nn)              const;          // normalized detector response (using AliFlowConstants::fgBayesian[] )
+  Float_t       PidProb(Int_t nn)              const;                   // normalized detector response (using AliFlowConstants::fgBayesian[] )
   TVector      PidProbs()                      const; 
   void          PidProbs(Float_t pidN[AliFlowConstants::kPid])    const; 
-  void          RawPidProbs(Float_t pidV[AliFlowConstants::kPid]) const;       // raw ESD detector responses
- // Gets - Detector response
-  Float_t       Chi2TPC()     const;
-  Int_t         FitPtsTPC()   const;
-  Int_t         MaxPtsTPC()   const;
-  Float_t       DedxTPC()     const;
-  Float_t       Chi2ITS()     const;
-  Int_t         FitPtsITS()   const;
-  Int_t         MaxPtsITS()   const;
-  Float_t       DedxITS()     const;
-  Float_t       Chi2TRD()     const;
-  Int_t         NhitsTRD()    const;
-  Int_t         MaxPtsTRD()   const;
-  Float_t       SigTRD()      const;
-  Float_t       Chi2TOF()     const;
-  Int_t         NhitsTOF()    const;
-  Int_t         MaxPtsTOF()   const;
-  Float_t       TofTOF()      const;  
-  Float_t       PatTPC()      const;           // new
-  Float_t       PatITS()      const;           // new
-  Float_t       PatTRD()      const;           // new
-  Float_t       PatTOF()      const;           // new
+  void          RawPidProbs(Float_t pidV[AliFlowConstants::kPid]) const; // raw ESD detector responses
+  Float_t       ElectronPositronProb()         const { return PidProb(0) ; } 
+  Float_t       MuonPlusMinusProb()            const { return PidProb(1) ; }
+  Float_t       PionPlusMinusProb()            const { return PidProb(2) ; }
+  Float_t       KaonPlusMinusProb()            const { return PidProb(3) ; }
+  Float_t       ProtonPbarProb()               const { return PidProb(4) ; }
+  Float_t       DeuteriumAntiDeuteriumProb()   const { return PidProb(5) ; }
+  Int_t         MostLikelihoodPID()            const { return fMostLikelihoodPID ; }
 
+ // Gets - Detector response
+  Float_t       Chi2TPC()     const { return fFitChi2[0] ; }
+  Float_t       Chi2ITS()     const { return fFitChi2[1] ; }
+  Float_t       Chi2TRD()     const { return fFitChi2[2] ; }
+  Float_t       Chi2TOF()     const { return fFitChi2[3] ; }
+  Int_t         FitPtsTPC()   const { return fFitPts[0]  ; }
+  Int_t         FitPtsITS()   const { return fFitPts[1]  ; }
+  Int_t         NhitsTRD()    const { return fFitPts[2]  ; }
+  Int_t         NhitsTOF()    const { return fFitPts[3]  ; }
+  Int_t         MaxPtsTPC()   const { return fMaxPts[0]  ; }
+  Int_t         MaxPtsITS()   const { return fMaxPts[1]  ; }
+  Int_t         MaxPtsTRD()   const { return fMaxPts[2]  ; }
+  Int_t         MaxPtsTOF()   const { return fMaxPts[3]  ; }
+  Float_t       DedxTPC()     const { return fDedx[0]   ; }
+  Float_t       DedxITS()     const { return fDedx[1]   ; }
+  Float_t       SigTRD()      const { return fDedx[2]   ; }
+  Float_t       TofTOF()      const { return fDedx[3]   ; }
+  Float_t       PatTPC()      const { return fMom[0] ; }
+  Float_t       PatITS()      const { return fMom[1] ; }
+  Float_t       PatTRD()      const { return fMom[2] ; }
+  Float_t       PatTOF()      const { return fMom[3] ; }
 
  // Sets - Track variables
   void SetPid(const Char_t* pid);
-  void SetCharge(Int_t charge);
-  void SetPhi(Float_t phi);
-  void SetEta(Float_t eta);
-  void SetPt(Float_t pt);
-  void SetPhiGlobal(Float_t phi);
-  void SetEtaGlobal(Float_t eta);
-  void SetPtGlobal(Float_t pt);
-  void SetDcaSigned(Float_t xy, Float_t z = 0.);
-  void SetTransDcaSigned(Float_t xy);
-  void SetChi2(Float_t chi2);
-  void SetTrackLength(Float_t tl);
-  void SetZFirstPoint(Float_t zFirst);
-  void SetZLastPoint(Float_t zLast);
-  void SetLabel(Int_t label);
+  void SetCharge(Int_t charge)                           { fMostLikelihoodPID = TMath::Sign(TMath::Abs(fMostLikelihoodPID),charge) ; }
+  void SetPhi(Float_t phi)                       { fPhi = phi; }
+  void SetEta(Float_t eta)                       { fEta = eta; }
+  void SetPt(Float_t pt)                         { fPt = pt; }
+  void SetPhiGlobal(Float_t phi)                 { fPhiGlobal = phi; }
+  void SetEtaGlobal(Float_t eta)                 { fEtaGlobal = eta; }
+  void SetPtGlobal(Float_t pt)                   { fPtGlobal = pt; }
+  void SetDcaSigned(Float_t xy, Float_t z = 0.)   { fDcaSigned[0] = xy ; fDcaSigned[1] = z ; }
+  void SetChi2(Float_t chi2)                     { fChi2 = chi2; }
+  void SetTrackLength(Float_t tl)                { fTrackLength = tl; }
+  void SetZFirstPoint(Float_t zFirst)            { fZFirstPoint = zFirst; }
+  void SetZLastPoint(Float_t zLast)              { fZLastPoint = zLast; }
+  void SetLabel(Int_t label)                     { fLabel = label ; }
+  void SetDcaError(Float_t xye, Float_t ze, Float_t xyze = 0.) { fDcaError[0] = xye ; fDcaError[1] = ze ; fDcaError[2] = xyze ; }
+
  // Sets - P.id.
-  void SetMostLikelihoodPID(Int_t val); 
-  void SetElectronPositronProb(Float_t val);
-  void SetMuonPlusMinusProb(Float_t val);
-  void SetPionPlusMinusProb(Float_t val);
-  void SetKaonPlusMinusProb(Float_t val);
-  void SetProtonPbarProb(Float_t val);
-  void SetDeuteriumAntiDeuteriumProb(Float_t val);
+  void SetMostLikelihoodPID(Int_t val)           { fMostLikelihoodPID = val ; }
+  void SetElectronPositronProb(Float_t val)      { fPidProb[0] = TMath::Abs(val) ; } 
+  void SetMuonPlusMinusProb(Float_t val)         { fPidProb[1] = TMath::Abs(val) ; } 
+  void SetPionPlusMinusProb(Float_t val)         { fPidProb[2] = TMath::Abs(val) ; } 
+  void SetKaonPlusMinusProb(Float_t val)         { fPidProb[3] = TMath::Abs(val) ; } 
+  void SetProtonPbarProb(Float_t val)            { fPidProb[4] = TMath::Abs(val) ; } 
+  void SetDeuteriumAntiDeuteriumProb(Float_t val) { fPidProb[5] = TMath::Abs(val) ; }
+
  // Sets - Detector response
-  void SetChi2TPC(Float_t chi2);
-  void SetFitPtsTPC(Int_t fitPts);
-  void SetMaxPtsTPC(Int_t maxPts);
-  void SetDedxTPC(Float_t dedx);
-  void SetChi2ITS(Float_t chi2);
-  void SetFitPtsITS(Int_t nhits);
-  void SetMaxPtsITS(Int_t maxPts);
-  void SetDedxITS(Float_t dedx);
-  void SetChi2TRD(Float_t chi2);
-  void SetNhitsTRD(Int_t fitPts);
-  void SetMaxPtsTRD(Int_t maxPts);
-  void SetSigTRD(Float_t dedx);
-  void SetChi2TOF(Float_t chi2);
-  void SetNhitsTOF(Int_t fitPts);
-  void SetMaxPtsTOF(Int_t maxPts);
-  void SetTofTOF(Float_t dedx);
-  void SetPatTPC(Float_t p);           // new
-  void SetPatITS(Float_t p);           // new
-  void SetPatTRD(Float_t p);           // new
-  void SetPatTOF(Float_t p);           // new
+  void SetChi2TPC(Float_t chi2)                          { fFitChi2[0] = chi2   ; }
+  void SetChi2ITS(Float_t chi2)                          { fFitChi2[1] = chi2   ; }
+  void SetChi2TRD(Float_t chi2)                          { fFitChi2[2] = chi2   ; }
+  void SetChi2TOF(Float_t chi2)                          { fFitChi2[3] = chi2   ; }
+  void SetFitPtsTPC(Int_t fitPts)                { fFitPts[0]  = fitPts ; }
+  void SetFitPtsITS(Int_t nhits)                 { fFitPts[1]  = nhits ; }
+  void SetNhitsTRD(Int_t fitPts)                 { fFitPts[2]  = fitPts ; }
+  void SetNhitsTOF(Int_t hits)                   { fFitPts[3]  = hits ; }
+  void SetMaxPtsTPC(Int_t maxPts)                { fMaxPts[0]  = maxPts ; }
+  void SetMaxPtsITS(Int_t maxPts)                { fMaxPts[1]  = maxPts ; }
+  void SetMaxPtsTRD(Int_t maxPts)                { fMaxPts[2]  = maxPts ; }
+  void SetMaxPtsTOF(Int_t maxPts)                { fMaxPts[3]  = maxPts ; }
+  void SetDedxTPC(Float_t dedx)                          { fDedx[0]    = dedx   ; }
+  void SetDedxITS(Float_t dedx)                          { fDedx[1]    = dedx   ; }
+  void SetSigTRD(Float_t trd)                    { fDedx[2]    = trd   ; }
+  void SetTofTOF(Float_t tof)                    { fDedx[3]    = tof   ; }
+  void SetPatTPC(Float_t p)                      { fMom[0] = p ; }
+  void SetPatITS(Float_t p)                      { fMom[1] = p ; }
+  void SetPatTRD(Float_t p)                      { fMom[2] = p ; }
+  void SetPatTOF(Float_t p)                      { fMom[3] = p ; }
+
+ // Selection methods
+  void  SetSelect(Int_t harmonic, Int_t selection)                   { fSelection[harmonic][selection] = kTRUE ; }
+  void  SetSubevent(Int_t harmonic, Int_t selection, Int_t subevent) { fSubevent[harmonic][selection] = subevent ; }
+  void  ResetSelection() ;
+  void  PrintSelection() const ;
+  Bool_t Select(Int_t harmonic, Int_t selection, Int_t subevent= -1) const ;
+
  // TRICKY
   void SetConstrainable();
   void SetUnConstrainable();
 
- // Selection's methods
-  Bool_t Select(Int_t harmonic, Int_t selection, Int_t subevent= -1) const;
-  void  SetSelect(Int_t harmonic, Int_t selection);
-  void  SetSubevent(Int_t harmonic, Int_t selection, Int_t subevent);
-  void  PrintSelection() ;
-  void  ResetSelection() ;
-
 
 private:
 
+ // to make the code checker happy
+  AliFlowTrack &operator=(const AliFlowTrack &flowTrack) ; // Assignment Operator (dummy)
+
  // Data Members
   Float_t  fPhi;                               // azimuthal angle of the constrained track
   Float_t  fEta;                               // pseudorapidity of the constrained track
@@ -167,24 +175,24 @@ private:
   Float_t  fTrackLength;                       // lenght of the track
   Int_t    fMostLikelihoodPID;                 // PDG code of the most probable P.Id.
   Double_t fDcaSigned[2] ;                     // positive or negative tracks -> P changes differently including vertex ...
-  //Double_t fDcaError[2] ;                    // error over the DCA (next to come)
+  Double_t fDcaError[3] ;                      // error over the DCA
   Float_t  fPhiGlobal;                         // azimuthal angle of the unconstrained track
   Float_t  fEtaGlobal;                         // pseudorapidity of the unconstrained track
   Float_t  fPtGlobal;                          // transverse momentum of the unconstrained track 
   Int_t    fLabel ;                            // Label of the track (link: KineTree-ESD) 
  // -
-  Float_t  fPidProb[AliFlowConstants::kPid] ;          // Array of probability to be   (e,mu,pi,k,p,d)
-  Int_t    fFitPts[4] ;                        // Array of Fit Points          (in: TPC,ITS,TRD,TOF)
-  Int_t    fMaxPts[4] ;                        // Array of Foundable Clusters  (in: TPC,ITS,TRD,TOF)
-  Float_t  fFitChi2[4] ;                       // Array of Chi2                (in: TPC,ITS,TRD,TOF)
-  Float_t  fDedx[4] ;                          // Array of dE/dx               (in: TPC,ITS,TRD,TOF)
-  Float_t  fMom[4] ;                           // Array of momentum at the entrance of TPC,ITS,TRD,TOF     
+  Float_t  fPidProb[AliFlowConstants::kPid] ;  // Array of probabilities to be (e,mu,pi,k,p,d)
+  Int_t    fFitPts[4] ;                        // Fit Points (in: TPC,ITS,TRD,TOF)
+  Int_t    fMaxPts[4] ;                        // Foundable Clusters (in: TPC,ITS,TRD,TOF)
+  Float_t  fFitChi2[4] ;                       // Chi2 (in: TPC,ITS,TRD,TOF)
+  Float_t  fDedx[4] ;                          // dE/dx from TPC and ITS , TRD signal , time of flight (TOF)
+  Float_t  fMom[4] ;                           // Track momentum at the entrance of TPC,ITS,TRD,TOF     
 
  // Selection's array for R.P. & sub-event selection (not stored)  
   Bool_t   fSelection[AliFlowConstants::kHars][AliFlowConstants::kSels]; //! 
   Short_t  fSubevent[AliFlowConstants::kHars][AliFlowConstants::kSels];         //! 
 
-  ClassDef(AliFlowTrack,4) ;                   // macro for rootcint
+  ClassDef(AliFlowTrack,5) ;                   // macro for rootcint
 };
 
 #endif
index 761fdb8ea46208f9bfb425ae638b4cbc820fb992..e1c5810bc9234e2350379eb09d6dd06e90da13fc 100644 (file)
@@ -17,7 +17,9 @@
 //
 
 #include "AliFlowV0.h"
-#include "AliFlowConstants.h"
+#include "AliFlowTrack.h"
+#include "AliFlowEvent.h"
+
 #include <iostream>
 using namespace std; //required for resolving the 'cout' symbol
 
@@ -38,6 +40,7 @@ AliFlowV0::AliFlowV0()
  fLabel = 0 ;
  for(Int_t dd=0;dd<3;dd++) { fCrossPoint[dd] = 0. ; }
  for(Int_t dd=0;dd<2;dd++) { fDaughters[dd] = 0  ; }
+ fPointAngle = 0. ;
 }
 //////////////////////////////////////////////////////////////////////////////
 AliFlowV0::AliFlowV0(const Char_t* name) 
@@ -73,70 +76,37 @@ Float_t  AliFlowV0::Y() const
  if(TMath::Abs((Float_t)P()) == TMath::Abs((Float_t)Pt()))     { return 0. ; }
  else if(TMath::Abs((Float_t)P()) < TMath::Abs((Float_t)Pt())) { cout << "v0: " << GetName() << "has  Pt() > P() !!!" << endl ; return -1000. ; }
  // -
float M = Mass() ; 
double Pz = TMath::Sqrt(P()*P() - Pt()*Pt()); 
- if (Eta() < 0) { Pz = -Pz ; }
double E = TMath::Sqrt(P()*P() + M*M) ;
float rapidity = 0.5*TMath::Log((E + Pz)/(E - Pz)) ;
Float_t mass = Mass() ; 
Double_t pz = TMath::Sqrt(P()*P() - Pt()*Pt()); 
+ if(Eta() < 0) { pz = -pz ; }
Double_t e = TMath::Sqrt(P()*P() + mass*mass) ;
Float_t rapidity = 0.5 * TMath::Log((e + pz)/(e - pz)) ;
  return rapidity ;
 }
 //////////////////////////////////////////////////////////////////////////////
-void AliFlowV0::SetDaughters(AliFlowTrack* pos, AliFlowTrack* neg) 
-{ 
- // Sets positive and negative daughter tracks from the TrackCollection()
-
- fDaughters[0] = pos ; 
- fDaughters[1] = neg ; 
-}
-//////////////////////////////////////////////////////////////////////////////
-void  AliFlowV0::CrossPoint(Float_t Pxyz[3]) const 
-{
- // Coordinates of the v0
-
- for(Int_t ii=0;ii<3;ii++) { Pxyz[ii] = fCrossPoint[ii] ; }
-}
-//////////////////////////////////////////////////////////////////////////////
-// TVector3 AliFlowV0::CrossPoint() const 
-// {
-//  // Coordinates of the v0
-// 
-//  TVector3 pxyz ;
-//  pxyz.SetXYZ(fCrossPoint[0],fCrossPoint[1],fCrossPoint[2]) ;
-//  return pxyz ; 
-// }
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowV0::SetCrossPoint(Float_t pox,Float_t poy,Float_t poz)
-{ 
- // Sets the coordinates of the v0
-
- fCrossPoint[0] = pox ; fCrossPoint[1] = poy ; fCrossPoint[2] = poz ; 
-}
-//////////////////////////////////////////////////////////////////////////////
 const char* AliFlowV0::Pid() const
 {
- // Returns the P.Id. in characters (,...) basing on the stored pdg code 
- // (MostLikelihoodPID()) .
+ // Returns the P.Id. in char* basing on the stored pdg code (MostLikelihoodPID()) .
  
  const char *name[] = {"gamma","K0","K0s","K0l","Lambda0"} ;
- int pdg_code = TMath::Abs(MostLikelihoodPID()) ;
+ int pdgCode = TMath::Abs(MostLikelihoodPID()) ;
 
- TString p_id = "" ;
- if(pdg_code == 22)       { p_id = name[0] ; }
- else if(pdg_code == 311)  { p_id = name[1] ; }
- else if(pdg_code == 310)  { p_id = name[2] ; }
- else if(pdg_code == 130)  { p_id = name[3] ; }
- else if(pdg_code == 3122) { p_id = name[4] ; }
+ TString pId = "" ;
+ if(pdgCode == 22)       { pId = name[0] ; }
+ else if(pdgCode == 311)  { pId = name[1] ; }
+ else if(pdgCode == 310)  { pId = name[2] ; }
+ else if(pdgCode == 130)  { pId = name[3] ; }
+ else if(pdgCode == 3122) { pId = name[4] ; }
  // ...
- else                     { p_id = "0" ; }
+ else                    { pId = "0" ; }
  
- return p_id.Data() ; 
+ return pId.Data() ; 
 }
 //////////////////////////////////////////////////////////////////////////////
 void AliFlowV0::SetPid(const Char_t* pid)              
 { 
- // Sets the P.Id. hypotesis of the track from a String imput ("K0","K0s",
- // "K0l","Lambda0"). The string itself is not stored, what is stored is the
- // PDG code.
+ // Sets the P.Id. hypotesis of the track from a char* imput ("K0","Lambda0",...). 
+ // The string itself is not stored, what is stored is the PDG code.
  
  if(strstr(pid,"gamma"))        { fMostLikelihoodPID = 22   ; }
  else if(strstr(pid,"K0"))      { fMostLikelihoodPID = 311  ; }
@@ -147,29 +117,3 @@ void AliFlowV0::SetPid(const Char_t* pid)
  else { fMostLikelihoodPID = 0 ; cout << "AliFlowV0 - !BAD IMPUT!" << endl ; }
 }
 //////////////////////////////////////////////////////////////////////////////
-Float_t  AliFlowV0::Mass()               const { return fMass ; }
-Float_t  AliFlowV0::Phi()                const { return fPhi; }             
-Float_t  AliFlowV0::Eta()                const { return fEta; }             
-Float_t  AliFlowV0::Pt()                 const { return fPt; }              
-Short_t  AliFlowV0::Charge()             const { return 0 ; }       
-Float_t  AliFlowV0::Dca()                const { return fDca ; }                 
-Float_t  AliFlowV0::Chi2()               const { return fChi2; }                 
-Float_t  AliFlowV0::CrossDca()           const { return fCrossDCA ; }
-Float_t  AliFlowV0::V0Lenght()           const { return TMath::Sqrt(fCrossPoint[0]*fCrossPoint[0] + fCrossPoint[1]*fCrossPoint[1] + fCrossPoint[2]*fCrossPoint[2]) ; }   
-Float_t  AliFlowV0::Sigma()              const { return fSigma ; }       
-Int_t   AliFlowV0::MostLikelihoodPID()   const { return fMostLikelihoodPID; } 
-Int_t    AliFlowV0::Label()               const { return fLabel ; }          
-AliFlowTrack* AliFlowV0::DaughterP()      const { return fDaughters[0] ; }
-AliFlowTrack* AliFlowV0::DaughterN()      const { return fDaughters[1] ; }
-//////////////////////////////////////////////////////////////////////////////
-void AliFlowV0::SetMostLikelihoodPID(Int_t val) { fMostLikelihoodPID = val ; } 
-void AliFlowV0::SetVmass(Float_t mass)                 { fMass = mass ; }
-void AliFlowV0::SetPhi(Float_t phi)            { fPhi = phi; }
-void AliFlowV0::SetEta(Float_t eta)            { fEta = eta; }
-void AliFlowV0::SetPt(Float_t pt)              { fPt = pt; }
-void AliFlowV0::SetChi2(Float_t chi2)          { fChi2 = chi2; }
-void AliFlowV0::SetDca(Float_t dca)             { fDca = dca; }
-void AliFlowV0::SetCrossDca(Float_t dca)        { fCrossDCA = dca ; }
-void AliFlowV0::SetSigma(Float_t sigma)                { fSigma = sigma ; }      
-void AliFlowV0::SetLabel(Int_t label)          { fLabel = label ; }
-//////////////////////////////////////////////////////////////////////////////
index 110b632d57b469f6e65200d7070b4d071a73c778..9ec46d550d208dc1c0aa4e81d8fa33f6a57b5e0d 100644 (file)
@@ -6,12 +6,14 @@
 //
 //////////////////////////////////////////////////////////////////////
 //
-// Description: part of AliFlowEvent, allow flow study of v0s .
+// Description: an array of V0s is part of AliFlowEvent, 
+//  this class allow flow study neutral secundary vertices (V0s)
+//  as they are reconstructer by AliRoot at the ESD level .
 //
 //////////////////////////////////////////////////////////////////////
 
-#ifndef AliFlowV0_h
-#define AliFlowV0_h
+#ifndef ALIFLOWV0_H
+#define ALIFLOWV0_H
 
 #include <string.h>
 #include <stdio.h>
 #include <iostream>
 #include <TROOT.h>
 #include "TMath.h"
-#include "TObject.h"
 #include "TNamed.h"
 
-#include "AliFlowConstants.h"
 #include "AliFlowTrack.h"
 
-class Flow ;
-
 class AliFlowV0 : public TNamed {
 
 public:
@@ -35,43 +33,53 @@ public:
                 AliFlowV0(const Char_t* name);
   virtual       ~AliFlowV0();
 
- // Gets - V0's variables
-  const Char_t* Pid()         const;
-  Float_t       Phi()         const;
-  Float_t       Eta()         const;
-  Float_t       Pt()          const;
-  Float_t       P()           const;
-  Float_t       Y()           const;
-  Short_t       Charge()      const;
-  Float_t       Dca()         const;
-  Float_t       Chi2()        const;
-  Float_t       Mass()        const; 
-  AliFlowTrack* DaughterP()   const; 
-  AliFlowTrack* DaughterN()   const; 
-  Float_t       V0Lenght()    const;
-  Float_t       Sigma()       const;
-  void          CrossPoint(Float_t Pxyz[3]) const;
-  //TVector3      CrossPoint() const ;
-  Float_t       CrossDca()    const;
-  Int_t        MostLikelihoodPID() const;
-  Int_t         Label()                const;
- // Sets - V0's variables
+ // Gets
+  const Char_t* Pid()          const ;
+  Float_t       P()            const ;   
+  Float_t       Y()            const ;
+  Float_t       Phi()          const { return fPhi; }  
+  Float_t       Eta()          const { return fEta; }  
+  Float_t       Pt()           const { return fPt; }   
+  Short_t       Charge()       const { return 0 ; }
+  Float_t       Dca()          const { return fDca ; }
+  Float_t       Chi2()         const { return fChi2; }
+  Float_t       Mass()         const { return fMass ; }
+  AliFlowTrack* DaughterP()    const { return fDaughters[0] ; } 
+  AliFlowTrack* DaughterN()    const { return fDaughters[1] ; } 
+  Float_t       V0Lenght()     const { return TMath::Sqrt(fCrossPoint[0]*fCrossPoint[0] + fCrossPoint[1]*fCrossPoint[1] + fCrossPoint[2]*fCrossPoint[2]) ; }
+  Float_t       Sigma()        const { return fSigma ; }
+  Float_t       CrossPointX()  const { return fCrossPoint[0] ; }
+  Float_t       CrossPointY()  const { return fCrossPoint[1] ; } 
+  Float_t       CrossPointZ()  const { return fCrossPoint[2] ; }
+  Float_t       DaughtersDca() const { return fCrossDCA ; }
+  Int_t         Label()        const { return fLabel ; }
+  Float_t       GetCosPointingAngle()      const { return fPointAngle ; }
+  Int_t        MostLikelihoodPID()         const { return fMostLikelihoodPID; } 
+  void          CrossPoint(Float_t Pxyz[3]) const { for(Int_t ii=0;ii<3;ii++) { Pxyz[ii] = fCrossPoint[ii] ; } }
+
+ // Sets
   void SetPid(const Char_t* pid);
-  void SetPhi(Float_t phi);    
-  void SetEta(Float_t eta);    
-  void SetPt(Float_t pt);      
-  void SetChi2(Float_t chi2) ; 
-  void SetVmass(Float_t mass);
-  void SetCrossPoint(Float_t pox,Float_t poy,Float_t poz);
-  void SetCrossDca(Float_t dca) ;
-  void SetDca(Float_t dca) ; 
-  void SetSigma(Float_t sigma) ;         
-  void SetDaughters(AliFlowTrack* pos, AliFlowTrack* neg);
-  void SetMostLikelihoodPID(Int_t pdg_code);
-  void SetLabel(Int_t label);
+  void SetPhi(Float_t phi)             { fPhi = phi; }   
+  void SetEta(Float_t eta)             { fEta = eta; }   
+  void SetPt(Float_t pt)               { fPt = pt; }     
+  void SetChi2(Float_t chi2)           { fChi2 = chi2; }   
+  void SetVmass(Float_t mass)          { fMass = mass ; }
+  void SetDca(Float_t dca)              { fDca = dca; }
+  void SetSigma(Float_t sigma)         { fSigma = sigma ; }      
+  void SetLabel(Int_t label)           { fLabel = label ; }
+  void SetDaughtersDca(Float_t dca)     { fCrossDCA = dca ; }
+  void SetCosPointingAngle(Float_t cos) { fPointAngle = cos ; }
+  void SetMostLikelihoodPID(Int_t pdgCode)               { fMostLikelihoodPID = pdgCode ; }
+  void SetCrossPoint(Float_t pox,Float_t poy,Float_t poz) { fCrossPoint[0] = pox ; fCrossPoint[1] = poy ; fCrossPoint[2] = poz ; }
+  void SetDaughters(AliFlowTrack* pos, AliFlowTrack* neg) { fDaughters[0] = pos ; fDaughters[1] = neg ; }
+
 
 private:
 
+ // to make the code checker happy
+  AliFlowV0(const AliFlowV0 &flowV0) ;                   // Copy Constructor (dummy)
+  AliFlowV0 &operator=(const AliFlowV0 &flowV0) ; // Assignment Operator (dummy)
+
  // Data Members
   Float_t  fPhi;                               // reconstructed azimuthal angle of the v0
   Float_t  fPt;                                        // reconstructed transverse momentum of the v0 
@@ -80,13 +88,14 @@ private:
   Float_t  fMass;                              // reconstructed v0 mass 
   Float_t  fDca;                               // distance of closest approach of the reconstructed v0 to the main vertex
   Float_t  fCrossPoint[3] ;                    // crossing point coordinates of the two daughter tracks
-  Float_t  fCrossDCA ;                         // DCA of the 2 tracks at the crossing point 
-  Float_t  fSigma ;                            //! DCA of the 2 tracks at the crossing point 
-  Int_t    fMostLikelihoodPID;                 // most probable P.Id. hypotesis (...need to be implemented)
+  Float_t  fCrossDCA ;                         // DCA between the 2 daughter tracks at the crossing point 
+  Float_t  fSigma ;                            // sigma of the DCA of the 2 daughter tracks at the crossing point 
   Int_t    fLabel ;                            // Label of the V0 (link: KineTree-ESD) 
-  AliFlowTrack* fDaughters[2] ;                        // daughter particles' pointers 
+  AliFlowTrack* fDaughters[2] ;                        // daughter tracks (pointers to the TracksCollection())
+  Int_t    fMostLikelihoodPID;                 // most probable P.Id. hypotesis
+  Float_t  fPointAngle;                        // cosine of the pointing angle
   
-  ClassDef(AliFlowV0,1) ;                      // macro for rootcint
+  ClassDef(AliFlowV0,2) ;                      // macro for rootcint
 };
 
 #endif
index b0dd31524adea8fdb187d85d0212bae1ac9cbb09..4a48047d32457282b670fa8c06f4c3c7319156d0 100644 (file)
@@ -61,8 +61,9 @@ class AliFlowWeighter {
 
  private:
 
-  //AliFlowWeighter(const AliFlowWeighter &flowWgt)            { flowWgt.fPhiBins ; }  // Copy Constructor (dummy)
-  //AliFlowWeighter &operator=(const AliFlowWeighter &flowAnal) { return *this ; }     // Assignment Operator
+ // to make the code checker happy
+  AliFlowWeighter(const AliFlowWeighter &flowWgt) ;            // Copy Constructor (dummy)
+  AliFlowWeighter &operator=(const AliFlowWeighter &flowAnal) ; // Assignment Operator
 
  // enumerators etc.                       
   Int_t            fEventNumber ;                              //! progressive enumeration of AliFlowEvents
index 71cc93ef9e5be30688e064848221e44c51f65da8..7d3c20700ccbc1edd695cc95c232b11cc0295757 100644 (file)
 #include <TObjArray.h>
 #include <TSelector.h>
 
-#include "AliLog.h"     
-#include "AliESD.h"     
+#include "AliLog.h"              
+#include "AliESD.h"              
 #include "AliESDtrack.h"  
-#include "AliESDv0.h"    
+#include "AliESDv0.h"             
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -138,7 +138,7 @@ void AliSelectorFoF::Begin(TTree*)
 
  // flags
  fDoNothing     = kFALSE ;  // kFALSE ;
- fOnFlyAnalysis = kTRUE ;  // kTRUE ;    
+ fOnFlyAnalysis = kTRUE ;   // kTRUE ;    
  fOnFlyWeight   = kFALSE ;  // kTRUE ;
  fSaveFlowEvents= kTRUE ;   // kTRUE ;
 
@@ -220,10 +220,10 @@ void AliSelectorFoF::Begin(TTree*)
    fFlowAnal = new AliFlowAnalyser(fFlowSelect) ;
 
   // Wgt file (read)
-   //TString wgtFileName = "fFlowPhiWgt.root" ;
-   //TFile* wgtFile = new TFile(wgtFileName.Data(),"READ");
-   //fFlowAnal->FillWgtArrays(wgtFile) ; // fix this !!!
-   //cout << " . Weights from  : " << fFlowAnal->GetWgtFileName() << "  . " << endl ;
+   TString wgtFileName = "fof_flowWgts.root" ;
+   TFile* wgtFile = new TFile(wgtFileName.Data(),"READ");
+   if(!wgtFile || wgtFile->IsZombie()) { cout << " . NO phi Weights . " << endl ;}
+   else { fFlowAnal->FillWgtArrays(wgtFile) ; cout << " . Weights from  : " << fFlowAnal->GetWgtFileName() << "  . " << endl ; }
 
   // analysis file (output)
    fFlowAnal->SetHistFileName(fFlowAnalysisFileName.Data()) ;
@@ -232,12 +232,12 @@ void AliSelectorFoF::Begin(TTree*)
   // Analysis settings
    fFlowAnal->SetFlowForV0(kFALSE) ;         // default kTRUE.
    fFlowAnal->SetEtaSub() ;            // default kFALSE
-   //fFlowAnal->SetV1Ep1Ep2() ;        // default kFALSE.
-   fFlowAnal->SetShuffle() ;           // default kFALSE. shuffles track array
-   //fFlowAnal->SetRedoWgt();            // default kFALSE. recalculates phiWgt (even if phiWgt file is already there)
-   fFlowAnal->SetUsePhiWgt(kFALSE) ;   // default kTRUE if phiWgt file is there, kFALSE if not (& phiWgt file is created)
+   //fFlowAnal->SetV1Ep1Ep2() ;          // default kFALSE.
+   //fFlowAnal->SetShuffle() ;           // default kFALSE. shuffles track array
+   //fFlowAnal->SetRedoWgt();           // default kFALSE. recalculates phiWgt (even if phiWgt file is already there)
+   fFlowAnal->SetUsePhiWgt(kFALSE) ;  // default kTRUE if phiWgt file is there, kFALSE if not (& phiWgt file is created)
    fFlowAnal->SetUseOnePhiWgt() ; // or // fFlowAnal->SetUseFirstLastPhiWgt() ; // uses 1 or 3 wgt histograms (default is 1)
-   fFlowAnal->SetUseBayWgt(kFALSE) ;   // default kFALSE. uses bayesian weights in P.id.
+   fFlowAnal->SetUseBayWgt(kFALSE) ;    // default kFALSE. uses bayesian weights in P.id.
    //fFlowAnal->SetUsePtWgt(); // default kFALSE. uses pT as a weight for RP determination
    //fFlowAnal->SetUseEtaWgt();        // default kFALSE. uses eta as a weight for RP determination
    fFlowAnal->Init() ;
@@ -357,7 +357,8 @@ Bool_t AliSelectorFoF::Process(Long64_t entry)
   cout << " event !!! " << entry << endl ;
 
   fRunID = fESD->GetRunNumber() ;
-  fEventNumber = fESD->GetEventNumber() ;
+  //  fEventNumber = fESD->GetEventNumber() ;
+  fEventNumber = -1 ;
   fNumberOfTracks = fESD->GetNumberOfTracks() ;
   fNumberOfV0s = fESD->GetNumberOfV0s() ;
 
@@ -370,8 +371,8 @@ Bool_t AliSelectorFoF::Process(Long64_t entry)
  // Instantiate a new AliFlowEvent
   cout << " filling the flow event :| " << endl ;
   fFlowEvent = fFlowMaker->FillFlowEvent(fESD) ;
-  if(!fFlowEvent) { cout << "!something bad occurred" << endl ; return kFALSE ; }
-  else                   { cout << " event filled :) " << entry << "                # t.G. ! #       "<< endl ; }
+  if(!fFlowEvent) { cout << "! something bad occurred !" << endl ; return kFALSE ; }
+  else                   { cout << "# event done :) " << entry << "                # ok ! #       " << endl ; }
 
  // Saves the AliFlowEvent
   if(fSaveFlowEvents)
@@ -379,7 +380,7 @@ Bool_t AliSelectorFoF::Process(Long64_t entry)
    cout << " saving flow event :| " << endl ;
    TString strID = "" ; strID += entry ; 
    fFlowfile->cd() ; fFlowEvent->Write(strID.Data()) ;
-   cout << " saved :) " << strID.Data() << "                # t.g. ! #       " << endl ; cout << endl ;  
+   cout << "# event saved :) " << strID.Data() << "                # ok ! #       " << endl ; cout << endl ;  
   }
 
  // Weights
@@ -387,7 +388,7 @@ Bool_t AliSelectorFoF::Process(Long64_t entry)
   { 
    cout << " weightening :| " << endl ;
    bool done = fFlowWeighter->WeightEvent(fFlowEvent) ;  
-   if(done) { cout << " weights done :) " << entry << "                # t.h.v. ! #       " << endl ; } 
+   if(done) { cout << "# weights done :) " << entry << "                # ok ! #       " << endl ; } 
   }
   
  // On-Fly Analysis
@@ -395,7 +396,8 @@ Bool_t AliSelectorFoF::Process(Long64_t entry)
   {
    cout << " doing analysis :| " << endl ;
    bool done = fFlowAnal->Analyse(fFlowEvent) ;
-   if(done) { cout << " analysis done :) " << entry << "                # t.h.v. ! #       " << endl ; } 
+   fFlowAnal->PrintEventQuantities() ;
+   if(done) { cout << "# analysis done :) " << entry << "                # ok ! #       " << endl ; } 
   }
    
   return kTRUE;
@@ -428,24 +430,25 @@ void AliSelectorFoF::Terminate()
 
   if(fDoNothing) { cout << "             ... & nothing was done ! " << endl ; cout << endl ; return ; }
 
+  cout << endl ;
   cout << "  nTracks:  " << fFlowMaker->GetNgoodTracks() << endl ;   
   cout << "  nV0s:  " << fFlowMaker->GetNgoodV0s()  << endl ;               
   cout << "  nTracks (|eta|<0.5):  " << fFlowMaker->GetNgoodTracksEta() << endl ; 
   cout << "  nTracks+:  " << fFlowMaker->GetNposiTracks() << endl ;         
   cout << "  nTracks-:  " << fFlowMaker->GetNnegaTracks() << endl ;         
   cout << "  nTracks unconstrained:  " << fFlowMaker->GetNunconstrained() << endl ;     
-  cout << "  Bayesian :  " ; 
+  cout << "  Bayesian (e,mu,pi,k,p) :  " ; 
   for(int ii=0;ii<5;ii++) { cout << fFlowMaker->GetBayesianNorm(ii) << "   " ; } 
-  cout << " . " << endl ; 
+  cout << " . " << endl ; cout << endl ;
 
   if(fOnFlyWeight) { fFlowWeighter->Finish() ; delete fFlowWeighter ; }
   
   if(fOnFlyAnalysis) 
   { 
-   cout << endl ; cout << "Particles normalized abundance:" << endl;  // shows the bayesian vector
    fFlowAnal->Resolution() ; cout << endl;
-   fFlowAnal->PrintRunBayesian() ; cout << endl;
    fFlowAnal->Finish() ;  cout << endl;
+   //cout << endl ; cout << "Particles normalized abundance:" << endl;  // shows the bayesian vector
+   //fFlowAnal->PrintRunBayesian() ; cout << endl;
    delete fFlowAnal ;
   }
      
index 4732105eb44479bbd89024f417f34a321b7e6807..c63ff64be83f1242b872e63e852e68e0d96bdb5f 100644 (file)
@@ -99,6 +99,7 @@ class AliSelectorFoF : public TSelector {
     void             DeleteKinematicsFile();
     TFile*            fKineFile;          //! pointer to Kinematics.root if the file was opened
 
+  // to make the code checker happy
     AliSelectorFoF(const AliSelectorFoF&);
     AliSelectorFoF& operator=(const AliSelectorFoF&);