namespace added for constants
authorsnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 16 May 2007 15:38:22 +0000 (15:38 +0000)
committersnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 16 May 2007 15:38:22 +0000 (15:38 +0000)
26 files changed:
PWG2/FLOW/AliFlowAnalyser.cxx
PWG2/FLOW/AliFlowAnalyser.h
PWG2/FLOW/AliFlowConstants.cxx
PWG2/FLOW/AliFlowConstants.h
PWG2/FLOW/AliFlowEvent.cxx
PWG2/FLOW/AliFlowEvent.h
PWG2/FLOW/AliFlowKineMaker.cxx
PWG2/FLOW/AliFlowKineMaker.h
PWG2/FLOW/AliFlowMaker.cxx
PWG2/FLOW/AliFlowMaker.h
PWG2/FLOW/AliFlowSelection.cxx
PWG2/FLOW/AliFlowSelection.h
PWG2/FLOW/AliFlowV0.cxx
PWG2/FLOW/AliFlowV0.h
PWG2/FLOW/AliFlowWeighter.h
PWG2/FLOW/AliSelectorFoF.cxx
PWG2/FLOW/AliSelectorFoF.h
PWG2/FLOW/macros/compilePWG2
PWG2/FLOW/macros/docMaker.C [new file with mode: 0644]
PWG2/FLOW/macros/efficiency2s.C [new file with mode: 0644]
PWG2/FLOW/macros/testAnal.C
PWG2/FLOW/macros/testFoF.C
PWG2/FLOW/macros/testKiner.C
PWG2/FLOW/macros/testMaker.C
PWG2/PWG2flowLinkDef.h
PWG2/libPWG2flow.pkg

index 4c03ada4f8f29dc535807b1062d39cbdaa017c32..ed931f9fa5404550a586e79c95fc9b4c3cf71d46 100644 (file)
@@ -94,6 +94,7 @@ AliFlowAnalyser::AliFlowAnalyser(const AliFlowSelection* flowSelect):
   fBayWgt(kFALSE), 
   fRePid(kFALSE), 
   fCustomRespFunc(kFALSE), 
+  fSub(0),
   fPtWgt(kFALSE),
   fEtaWgt(kFALSE), 
   fOnePhiWgt(kTRUE), 
@@ -107,6 +108,9 @@ AliFlowAnalyser::AliFlowAnalyser(const AliFlowSelection* flowSelect):
   fPidId(0), 
   fSelParts(0), 
   fSelV0s(0),
+  fTotalNumberOfEvents(0),
+  fTotalNumberOfTracks(0),
+  fTotalNumberOfV0s(0),
   fFlowEvent(0x0), 
   fFlowTrack(0x0), 
   fFlowV0(0x0), 
@@ -346,7 +350,11 @@ Bool_t AliFlowAnalyser::Init()
  fFlowV0s    = 0 ;
  fSelParts = 0 ;
  fSelV0s   = 0 ;
- for(Int_t ii=0;ii<3;ii++) { fVertex[ii] = 0 ; }
+ for(Int_t ii=0;ii<3;ii++) { fVertex[ii] = 0 ; }  
+ fTotalNumberOfEvents = 0 ;
+ fTotalNumberOfTracks = 0 ;
+ fTotalNumberOfV0s = 0 ;
 
  // Check for Reading weights: if weight file is not there, wgt arrays are not used (phiwgt & bayesian)
  if(!fPhiWgtFile) 
@@ -413,7 +421,7 @@ Bool_t AliFlowAnalyser::Init()
  float logpMin         =  -2.5 ;
  float logpMax         =   2.5 ;
  float pMin           =    0. ;
- float pMax           =  100. ;
+ float pMax           =   10. ;
  float dEdxMax         = 1000. ;
  float dEdxMaxTPC      = 1500. ;
  float tofmin         = 10000. ;
@@ -451,7 +459,7 @@ Bool_t AliFlowAnalyser::Init()
        kDedxBins         = 1000,
        kTofBins          = 1000,
        kTrdBins          = 100,
-       kMomenBins        = 500,
+       kMomenBins        = 100,
        kQbins            =  50,
        kLgBins           = 500,
        kMassBins         = 2200,
@@ -1276,7 +1284,7 @@ Bool_t AliFlowAnalyser::Init()
   fHistV0EtaPtPhi3D->SetYTitle("Pt (GeV/c)");
   fHistV0EtaPtPhi3D->SetZTitle("Phi (rad)");
  // Yield for all v0s
-  fHistV0YieldAll2D = new TH2D("FlowV0_YieldAll2D", "FlowV0_YieldAll2D", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax);
+  fHistV0YieldAll2D = new TH2D("FlowV0_PtEta2Dall", "FlowV0_PtEta2Dall", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax);
   fHistV0YieldAll2D->Sumw2();
   fHistV0YieldAll2D->SetXTitle("Pseudorapidty");
   fHistV0YieldAll2D->SetYTitle("Pt (GeV/c)");
@@ -1293,7 +1301,7 @@ Bool_t AliFlowAnalyser::Init()
 
  // Selected V0s ...  
  // Yield 
-  fHistV0YieldPart2D = new TH2D("FlowV0_Yield2Dsel", "FlowV0_Yield2Dsel", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax);
+  fHistV0YieldPart2D = new TH2D("FlowV0_PtEta2Dpart", "FlowV0_PtEta2Dpart", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax);
   fHistV0YieldPart2D->Sumw2();
   fHistV0YieldPart2D->SetXTitle("Pseudorapidty");
   fHistV0YieldPart2D->SetYTitle("Pt (GeV/c)");
@@ -1877,6 +1885,9 @@ Bool_t AliFlowAnalyser::Finish()
 
  fHistFile->Close() ;
 
+ cout << endl ;
+ cout << "    Finish()  -  tot. " << fTotalNumberOfEvents << " have been analyzed (with " << fTotalNumberOfTracks << " tracks and " << fTotalNumberOfV0s << " v0s) ."  << endl ; 
+ cout << endl ; 
  cout << "    Finish()  -  Histograms saved : " << fHistFileName.Data() << endl ; cout << endl ; 
 
  return kTRUE ;
@@ -2159,7 +2170,13 @@ Bool_t AliFlowAnalyser::Analyze(AliFlowEvent* flowEvent)
   if(fShuffle)    { fFlowEvent->RandomShuffle() ; }        // tracks re-shuffling
 
   fFlowEvent->SetSelections(fFlowSelect) ;                 // does the selection of tracks for r.p. calculation (sets flags in AliFlowTrack)
-  fFlowEvent->SetEtaSubs(fEtaSub) ;                        // setting for the subevents (eta or random)
+  
+  if(fSub == 1)       { fFlowEvent->SetEtaSubs() ; }       // setting for the subevents (eta, random, charged)
+  else if(fSub == -1) { fFlowEvent->SetChrSubs() ; }       // 
+  else                       { fFlowEvent->SetRndSubs() ; }        // ...
+  
+  fEtaSub = fFlowEvent->EtaSubs() ;
+
   fFlowEvent->MakeSubEvents() ;                            // makes the subevent, eta or random basing on the previous flag
 
   cout << " * 2 . Calculating event quantities all in one shoot . " << endl ; 
@@ -2326,7 +2343,8 @@ void AliFlowAnalyser::FillEventHistograms(AliFlowEvent* fFlowEvent)
    fHistFull[k].fHistFullHar[j].fHistMult->Fill((float)fMult[k][j]) ;
    fHistFull[k].fHistFullHar[j].fHistQnorm->Fill(fQnorm[k][j]) ;
   }
- }
+ } 
+ fTotalNumberOfEvents++ ;
  
  return ;
 }
@@ -2737,6 +2755,8 @@ void AliFlowAnalyser::FillParticleHistograms(TClonesArray* fFlowTracks)
  corrMultUnit /= (float)(AliFlowConstants::kHars * AliFlowConstants::kSels) ; 
  fHistMultPartUnit->Fill(corrMultUnit) ;
 
+ fTotalNumberOfTracks += fNumberOfTracks ;
+
  return ;
 }
 //-----------------------------------------------------------------------
@@ -2762,7 +2782,7 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
    fFlowSelect->SetHarmonic(j);
    double order  = (double)(j+1);
    float psii = 0. ; float psi2 = 0. ;
-   if(fFlowEvent->EtaSubs())          // particles with the opposite subevent
+   if(fEtaSub)        // particles with the opposite subevent
    {
     if(eta > 0) { psii = fPsiSub[1][k][j] ; }     //check
     else       { psii = fPsiSub[0][k][j] ; }
@@ -2826,7 +2846,7 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
 
     // Remove autocorrelations
     TVector2 qi;
-    if(!fFlowEvent->EtaSubs())   // random subevents
+    if(!fEtaSub)   // random subevents (or other)
     {
      if(order > 3. && !oddHar) // 2nd harmonic event plane
      { 
@@ -2990,8 +3010,8 @@ void AliFlowAnalyser::FillV0Histograms(TClonesArray* fFlowV0s)
   Char_t pid[10] ; strcpy(pid, fFlowV0->Pid()) ;    
   int labelPlus =  -1 ; 
   int labelMinus = -1 ;            
-  AliFlowTrack* daughterPlus = fFlowV0->DaughterP() ;  
-  AliFlowTrack* daughterMinus = fFlowV0->DaughterN() ; 
+  AliFlowTrack* daughterPlus = (AliFlowTrack*)(fFlowTracks->AddrAt(fFlowV0->DaughterP())) ;
+  AliFlowTrack* daughterMinus = (AliFlowTrack*)(fFlowTracks->AddrAt(fFlowV0->DaughterN())) ; ; 
   if(daughterPlus)  { labelPlus = daughterPlus->Label() ; }                
   if(daughterMinus) { labelMinus = daughterMinus->Label() ; }                      
 
@@ -3184,6 +3204,7 @@ void AliFlowAnalyser::FillV0Histograms(TClonesArray* fFlowV0s)
   //delete daughterMinus ; daughterMinus = 0 ;  
  }
  fHistV0MultPart->Fill(fSelV0s) ;
+ fTotalNumberOfV0s += fNumberOfV0s ;
 
  return ;
 }
index 84fa870cad5e4597e4933f0d4ffe9d0cbb9d1950..e38f1037f911b94e215e5d76147e2c4038989888 100644 (file)
@@ -27,14 +27,12 @@ class TH3F;
 class TProfile;
 class TProfile2D;
 class TOrdCollection;
-
 class TClonesArray;
 
 class AliFlowTrack;
 class AliFlowV0;
 class AliFlowEvent;
 class AliFlowSelection;
-class AliFlowConstants;
 
 class AliFlowAnalyser {
 
@@ -58,7 +56,8 @@ public:
   void     Weightening() ;                                     // Calculates weights and fills PhiWgt histograms
 
  // Options
-  void    SetEtaSub(Bool_t es = kTRUE)                         { fEtaSub = es ; }              // Set eta subevents
+  void    SetSub(Int_t sub = 0)                                { fSub = sub ; }                // Set subevents (1=eta,0=rnd,-1=charged)
+  void    SetEtaSub()                                          { SetSub(1) ; }         // Set subevents (1=eta,0=rnd,-1=charged)
   void     SetV1Ep1Ep2(Bool_t v1Ep1Ep2 = kTRUE)                { fV1Ep1Ep2 = v1Ep1Ep2 ; }      // Switches the v_1{EP1,EP2} calculation on/off
   void    SetShuffle(Bool_t sh = kTRUE)                        { fShuffle = sh ; }             // Set to re-shuffle evt tracks
   void     SetUsePhiWgt(Bool_t pw = kTRUE)                     { fReadPhiWgt = pw ; }          // Set to use phi weights (true by default...if there)
@@ -131,6 +130,7 @@ public:
   Bool_t          fBayWgt ;                                    //! Bayesian Weights are applied to P.Id. (default is false) 
   Bool_t          fRePid ;                                     //! Re-Calculates the P.Id. basing on the bayesian wgts (if plugged in)
   Bool_t          fCustomRespFunc ;                            //! A custom "detector response function" is used for P.Id (default is false -> the combined response function from the ESD will be used)
+  Int_t           fSub;                                        //! subevents (1=eta,0=rnd,-1=charged)
 
   Bool_t          fPtWgt ;                                     //! flag to use pT as a weight for RP determination
   Bool_t          fEtaWgt ;                                    //! flag to use eta as a weight for RP determination
@@ -153,6 +153,10 @@ public:
   Int_t            fSelParts ;                                 //! n. of tracks selected for correlation analysis
   Int_t            fSelV0s ;                                   //! n. of v0s selected for correlation analysis
 
+  Int_t           fTotalNumberOfEvents ;                       //! total number of analyzed AliFlowEvents
+  Int_t           fTotalNumberOfTracks ;                       //! total number of analyzed tracks
+  Int_t           fTotalNumberOfV0s ;                          //! total number of analyzed v0s
+
  // Internal pointers
   AliFlowEvent*     fFlowEvent ;                               //! pointer to AliFlowEvent
   AliFlowTrack*     fFlowTrack ;                               //! pointer to AliFlowTrack
index 499d25ea371abe527bd3757eb4502e74c7d108c2..4385a19158c14220d58b4bd2f6f92574da76ff8c 100644 (file)
@@ -16,7 +16,6 @@
 
 #include "AliFlowConstants.h"
 
-ClassImp(AliFlowConstants)
   
   Float_t  AliFlowConstants::fgEtaMin    = -2. ;
   Float_t  AliFlowConstants::fgEtaMax    =  2. ;
index 2a0f978c0d980697da2600eb35c697411269623b..4d3c2a151fadd91d6530ced0092c68ae0e692fe3 100644 (file)
 
 #include <TROOT.h>
 
-class AliFlowConstants {
-
-
- public:
+namespace AliFlowConstants {
 
  // Enumerators
   enum {
@@ -44,84 +41,42 @@ class AliFlowConstants {
  // new type
   typedef Double_t PhiWgt_t[kSels][kHars][kPhiBins];           // 3d_array type,used to import phi weights from histograms 
 
-//  // 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 (-0.9)
-  static Float_t  fgEtaMaxTpcOnly ;                            // eta upper limit of the full TPC acceptance (+0.9)
+  extern Float_t  fgEtaMin ;                                   // eta lower limit for FlowAnalysis histograms
+  extern Float_t  fgEtaMax ;                                   // eta upper limit for FlowAnalysis histograms
+  extern Float_t  fgPtMin ;                                    // pT lower limit for FlowAnalysis histograms
+  extern Float_t  fgPtMax ;                                    // pT upper limit for yield histograms
+  extern Float_t  fgPtMaxPart ;                                // pT upper limit for flow histograms
+  extern Float_t  fgPtWgtSaturation ;                          // flow(pT) saturation value
+  extern Float_t  fgEtaMinTpcOnly ;                            // eta lower limit of the full TPC acceptance (-0.9)
+  extern 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
-  static Float_t  fgEtaGood ;                                  // Good Rapidity interval (TPC acceptance)
-  static Int_t    fgCent0[AliFlowConstants::kCents] ;          // Expected Multiplicity for each Centrality class
-  static Double_t fgBayesian[AliFlowConstants::kPid] ;         // Expected particles' abundance
-  static Float_t  fgCentNorm[AliFlowConstants::kCents] ;       // Normalized Multiplicity for each Centrality class
-  static Float_t  fgMaxMult ;                                  // Maximum expected multiplicity
+  extern Float_t  fgEtaMid ;                                   // Mid-Rapidity interval, used for Centrality measurement
+  extern Float_t  fgEtaGood ;                                  // Good Rapidity interval (TPC acceptance)
+  extern Int_t    fgCent0[AliFlowConstants::kCents] ;          // Expected Multiplicity for each Centrality class
+  extern Double_t fgBayesian[AliFlowConstants::kPid] ;         // Expected particles' abundance
+  extern Float_t  fgCentNorm[AliFlowConstants::kCents] ;       // Normalized Multiplicity for each Centrality class
+  extern Float_t  fgMaxMult ;                                  // Maximum expected multiplicity
 
  // Experimental Conditions
-  static Double_t fgMagneticField;                             // magnetic field value (0.4 Tesla)
-  static Double_t fgCenterOfMassEnergy;                        // center of mass energy (5.5 TeV)
-  static Short_t  fgBeamMassNumberEast;                        // beam mass (Pb = 208)
-  static Short_t  fgBeamMassNumberWest;                        // beam mass (Pb = 208)
+  extern Double_t fgMagneticField;                             // magnetic field value (0.4 Tesla)
+  extern Double_t fgCenterOfMassEnergy;                        // center of mass energy (5.5 TeV)
+  extern Short_t  fgBeamMassNumberEast;                        // beam mass (Pb = 208)
+  extern 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 
+  extern Float_t  fgITSx ;                                     // inner ITS radial distance from the interaction point
+  extern Float_t  fgTPCx ;                                     // inner TPC radial distance from the interaction point 
+  extern Float_t  fgTRDx ;                                     // inner TRD radial distance from the interaction point 
+  extern Float_t  fgTOFx ;                                     // inner TOF radial distance from the interaction point 
 
  // ...
-  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)
+  extern Int_t    fgMClabel ;                                  // checking the simulation: pTrack->Label()<fMClabel = primary track 
+  extern Bool_t   fgDebug ;                                    // for more cout statements (debugging purpose)
+  extern Float_t  fgMaxInt ;                                   // big number (to avoid overflows)
 
-  ClassDef(AliFlowConstants,2)                                 // macro for rootcint
-};
+}
 
 #endif
 
index 52cecdce2aa9b437b03861f11c369151f2e59d58..4a990dc2f1335b9f3f499e6dac22ac22a9a261f3 100644 (file)
@@ -56,9 +56,9 @@ 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::fgEtaSubs        = kFALSE ;  // makes eta subevents
 Bool_t  AliFlowEvent::fgCustomRespFunc = kFALSE ;  // custom "detector response function" is used for P.Id (see AliFlowTrack)
+// - Eta Sub-Events (later used to calculate the resolution)
+Int_t   AliFlowEvent::fgEtaSubs        = 0 ;       // makes random subevents (0 = random , 1 = eta , -1 = charged)
 
 ClassImp(AliFlowEvent) 
 //-----------------------------------------------------------
@@ -73,8 +73,9 @@ AliFlowEvent::AliFlowEvent(Int_t lenght):
   fV0Collection(0x0), 
   fDone(kFALSE)        
 {
- // Default constructor: initializes the ObjArray of FlowTracks and FlowV0s, 
+ // not-Default constructor: initializes the ObjArray of FlowTracks and FlowV0s, 
  // cleans the internal variables, sets all the weights to 1, sets default flags.
+ // USE THIS WHEN CREATING ALIFLOWEVENTS
  
  for(int zz=0;zz<3;zz++) { fZDCenergy[zz] = 0. ; }
  for(int i=0;i<AliFlowConstants::kHars;i++) { fExtPsi[i] = 0. ; fExtRes[i] = 0.; }
@@ -105,12 +106,43 @@ AliFlowEvent::AliFlowEvent(Int_t lenght):
  
 }
 //-----------------------------------------------------------
+AliFlowEvent::AliFlowEvent():
+  fEventID(0), 
+  fRunID(0), 
+  fOrigMult(0), 
+  fL0Trigger(0), 
+  fZDCpart(0), 
+  fCentrality(-1), 
+  fTrackCollection(0x0), 
+  fV0Collection(0x0), 
+  fDone(kFALSE)        
+{
+ // Default constructor :  USE THIS WHEN READING ALIFLOWEVENTS
+
+ // Set Weights Arrays to 1 (default)
+ for(int nS=0;nS<AliFlowConstants::kSels;nS++)
+ {
+  for(int nH=0;nH<AliFlowConstants::kHars;nH++) 
+  {
+   for(int nP=0;nP<AliFlowConstants::kPhiBins;nP++) 
+   { 
+    // enable this with: SetOnePhiWgt()  
+    fPhiWgt[nS][nH][nP] = 1.     ; // cout << nS << nH << nP << "  val  " << fPhiWgt[nS][nH][nP] << endl ; 
+    // enable these with: SetFirstLastPhiWgt()  
+    fPhiWgtPlus[nS][nH][nP]  = 1. ; // cout << nS << nH << nP << "  val  " << fPhiWgtPlus[nS][nH][nP] << endl ; 
+    fPhiWgtMinus[nS][nH][nP] = 1. ; // cout << nS << nH << nP << "  val  " << fPhiWgtMinus[nS][nH][nP] << endl ; 
+    fPhiWgtCross[nS][nH][nP] = 1. ; // cout << nS << nH << nP << "  val  " << fPhiWgtCross[nS][nH][nP] << endl ; 
+   }
+  }
+ }
+}
+//-----------------------------------------------------------
 AliFlowEvent::~AliFlowEvent() 
 {
  // Default distructor: deletes the ObjArrays. 
  
- fTrackCollection->Delete() ; delete fTrackCollection ;
- fV0Collection->Delete()    ; delete fV0Collection ;
+ if(fTrackCollection) { delete fTrackCollection ; } // fTrackCollection->Delete() ; 
+ if(fV0Collection)    { delete fV0Collection ; }    // fV0Collection->Delete()    ; 
 }
 //-------------------------------------------------------------
 
@@ -601,8 +633,9 @@ void AliFlowEvent::MakeSubEvents() const
 {
  // Make random or eta sub-events
  
- if(fgEtaSubs)  { MakeEtaSubEvents() ; }
- else          { MakeRndSubEvents() ; }
+ if(fgEtaSubs == 1)        { MakeEtaSubEvents() ; }
+ else if(fgEtaSubs == -1)  { MakeChrSubEvents() ; }
+ else if(fgEtaSubs == 0)   { MakeRndSubEvents() ; }
 } 
 //-------------------------------------------------------------
 void AliFlowEvent::MakeRndSubEvents() const 
@@ -655,8 +688,7 @@ void AliFlowEvent::MakeRndSubEvents() const
 void AliFlowEvent::MakeEtaSubEvents() const
 {
  // Make subevents for positive and negative eta 
- // (when done, fgEtaSubs flag setted to kTRUE).
+
  int harN, selN = 0;
  // loop to set the SubEvent member
  for (selN = 0; selN < AliFlowConstants::kSels; selN++) 
@@ -678,6 +710,31 @@ void AliFlowEvent::MakeEtaSubEvents() const
  }
 }
 //-------------------------------------------------------------
+void AliFlowEvent::MakeChrSubEvents() const
+{
+ // Make subevents for positive and negative charged tracks
+ int harN, selN = 0;
+ // loop to set the SubEvent member
+ for (selN = 0; selN < AliFlowConstants::kSels; selN++) 
+ {
+  for (harN = 0; harN < AliFlowConstants::kHars; harN++) 
+  {
+   for(Int_t itr=0;itr<TrackCollection()->GetEntries();itr++) 
+   {
+    AliFlowTrack* pFlowTrack ;
+    pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
+    if(pFlowTrack->Select(harN, selN)) 
+    {
+     float charge = pFlowTrack->Charge();
+     if (charge > 0.) { pFlowTrack->SetSubevent(harN, selN, 0) ; } 
+     else             { pFlowTrack->SetSubevent(harN, selN, 1) ; }
+    }
+   }
+  }
+ }
+}
+//-------------------------------------------------------------
 void AliFlowEvent::RandomShuffle() 
 {
  // Randomly re-shuffles the tracks in the array; if a track is not
@@ -829,7 +886,7 @@ Int_t AliFlowEvent::UncorrNegMult(Float_t eta)  const
   AliFlowTrack* pFlowTrack ;
   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
   if((pFlowTrack->Charge()<0) && (TMath::Abs(pFlowTrack->Eta())<TMath::Abs(eta))) { negMult++ ; }
-  delete pFlowTrack ;
+  //delete pFlowTrack ;
  }
  return negMult; 
 }
@@ -845,7 +902,7 @@ Int_t AliFlowEvent::UncorrPosMult(Float_t eta)  const
   AliFlowTrack* pFlowTrack ;
   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
   if((pFlowTrack->Charge()>0) && (TMath::Abs(pFlowTrack->Eta())<TMath::Abs(eta))) { posMult++ ; }
-  delete pFlowTrack ;
+  //delete pFlowTrack ;
  }
  return posMult; 
 }
index 5e0155a1dc9ff5ded71705b05d5c83e7e6933947..60573be882397dc93f15c96f92f41384c24c5193 100644 (file)
@@ -34,7 +34,8 @@ class AliFlowEvent : public TNamed {
 
 public:                                                                           
                                                                                   
-  AliFlowEvent(Int_t length = 20000) ;                                                    
+  AliFlowEvent() ;                                // default constructor (to read events)                 
+  AliFlowEvent(Int_t length) ;                    // (new) constructor (to create events)                                                 
   virtual        ~AliFlowEvent();                                                 
                                                                                   
  // Arrays
@@ -56,6 +57,7 @@ public:
   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              MakeChrSubEvents() const ;                                  // Makes charged (+/-) 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)
@@ -74,8 +76,11 @@ public:
   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
   Bool_t     CustomRespFunc() const   { return fgCustomRespFunc ; }
+  Bool_t     EtaSubs() const         { if(fgEtaSubs == 1)  { return kTRUE ; } return kFALSE ; }   // Returns flag for charged (+/-) sub-events
+  Bool_t     RndSubs() const         { if(fgEtaSubs == 0)  { return kTRUE ; } return kFALSE ; }   // Returns flag for random sub-events
+  Bool_t     ChrSubs() const          { if(fgEtaSubs == -1) { return kTRUE ; } return kFALSE ; }   // Returns flag for eta sub-events
+  Int_t      Subs() const             { return fgEtaSubs ; }                                 // Returns flag for sub-events type (0 = random , 1 = eta , -1 = charged)
 
  // Gets
   Int_t      EventID() const               { return fEventID; }                          // Returns ID of the event
@@ -117,7 +122,9 @@ public:
   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 SetChrSubs()                                         { fgEtaSubs = -1 ; }
+  static void SetRndSubs()                                         { fgEtaSubs = 0 ; }
+  static void SetEtaSubs()                                         { fgEtaSubs = 1 ; }
   static void SetOnePhiWgt()                                       { fgOnePhiWgt = kTRUE ; }
   static void SetFirstLastPhiWgt()                                 { fgOnePhiWgt = kFALSE ; }
   static void SetPtWgt(Bool_t ptWgt = kTRUE)                       { fgPtWgt = ptWgt; }
@@ -174,8 +181,9 @@ private:
   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
   static Bool_t       fgCustomRespFunc ;                        //! A custom "detector response function" is used for P.Id
+  static Int_t        fgEtaSubs;                                 //! Flag type of Sub-Events (0 = random , 1 = eta , -1 = charged)
+
 
  // shortcuts (to speed up the execution)
   Bool_t   fDone ;                                                                             //! flag setted kTRUE when the loop is done
index 1671804c0bb3d68428dfd18c5d26a08b51ede100..bfbd15125b28a8894fc3ba840a87899b58d8f35d 100644 (file)
@@ -50,39 +50,21 @@ using namespace std; //required for resolving the 'cout' symbol
 ClassImp(AliFlowKineMaker) 
 //-----------------------------------------------------------------------
 AliFlowKineMaker::AliFlowKineMaker():
-  fKTree(0x0), fParticle(0x0), fParticlePDG(0x0),
-  fFlowEvent(0x0), fFlowTrack(0x0), fFlowV0(0x0)
+  fEventNumber(0), fPartNumber(0), fGoodTracks(0), fGoodV0s(0),
+  fGoodTracksEta(0), fPosiTracks(0), fNegaTracks(0), fUnconstrained(0),
+  fSumAll(0), fCutEvts(0), fCutParts(0), fNewAli(kFALSE), fLoopParts(kTRUE), fCounter(0), 
+  fKTree(0x0), fParticle(0x0), fParticlePDG(0x0), fCharge(0),
+  fRunID(0), fNumberOfEvents(0), fNumberOfParticles(0), fMagField(0), 
+  fFlowEvent(0x0), fFlowTrack(0x0), fFlowV0(0x0), 
+  fAbsEta(2.1), fElow(0.001), fEup(1000.), fPrimary(kTRUE)
 {
  // default constructor 
  // resets counters , sets defaults
  
- fNewAli = kFALSE ;
- // flags
- fLoopParts = kTRUE ;
- fCounter = 0 ; 
- // loop variable
- fRunID = 0 ;       
- fNumberOfParticles = 0 ;
- fEventNumber = 0 ; 
- fPartNumber = 0 ; 
- fEventNumber = 0 ;
- fMagField = 0. ;
- // counters
- fGoodTracks = 0  ;  
- fGoodV0s    = 0  ;    
- fGoodTracksEta = 0  ;
- fPosiTracks = 0  ;  
- fNegaTracks = 0  ;  
- fUnconstrained = 0  ;
- fCutParts   = 0  ;    
- for(Int_t bb=0;bb<5;bb++) { fBayesianAll[bb] = 0 ; } ;
- fSumAll = 0 ; 
- fCharge = 0 ;
-
- // trak cuts
- fPrimary = kTRUE ;
- fAbsEta = 2.1 ;                       
- fElow = 0.001 ; fEup = 1000. ;   
+ for(Int_t bb=0;bb<5;bb++) { fBayesianAll[bb] = 0 ; }
+ for(Int_t vv=0;vv<3;vv++) { fVertex[vv] = 0. ; }
+
+ // particle cut
  fLabel[0] = 0 ; fLabel[1] = -1 ;
 
 //  // TGeant3::AddParticlesToPdgDataBase() ---  Stolen From TGeant3.cxx ----(
@@ -118,7 +100,7 @@ AliFlowEvent* AliFlowKineMaker::FillFlowEvent(TTree* fKTree)
  // It loops on the stored TParticles and calls the methods to fill the 
  // arrays in the AliFlowEvent (charged -> tracks , neutral -> v0s) . 
 
- fFlowEvent = new AliFlowEvent() ; if(!fFlowEvent) { return 0 ; }
+ fFlowEvent = new AliFlowEvent(10000) ; if(!fFlowEvent) { return 0 ; }
  //cout << " -evt- " << fFlowEvent << endl ;
 
  fRunID = -1 ;
@@ -210,7 +192,7 @@ AliFlowTrack* AliFlowKineMaker::FillFlowTrack(TParticle* fParticle)
  Float_t y = fParticle->Vy() ; 
  Float_t z = fParticle->Vz() ; 
  Float_t xy = TMath::Sqrt(x*x + y*y) ; 
- fFlowTrack->SetDcaSigned(xy,z) ;                  
+ fFlowTrack->SetDcaSigned(xy,z) ;     // cout << "DCA :   xy = " << xy << "   z = " << z << endl ;         
 
  // error on the DCA = 0
  fFlowTrack->SetDcaError(0.,0.,0.) ;               
@@ -235,7 +217,7 @@ AliFlowTrack* AliFlowKineMaker::FillFlowTrack(TParticle* fParticle)
   fFlowTrack->SetEta(etaGl) ;                          
 
   // number of constrainable tracks with |eta| < AliFlowConstants::fgEtaGood (0.9)
-  if(TMath::Abs(etaGl) < AliFlowConstants::fgEtaGood)  { fGoodTracksEta++ ; }
+  if(TMath::Abs(etaGl) < AliFlowConstants::fgEtaMid)  { fGoodTracksEta++ ; }
  }
  else  // in case Constriction impossible for track, fill the UnConstrained (global)
  {
@@ -259,15 +241,15 @@ AliFlowTrack* AliFlowKineMaker::FillFlowTrack(TParticle* fParticle)
  Float_t pAt = (Float_t)Norm(pVecAt) ;
  
  Int_t nClus[9] ; Int_t nHits[9] ; 
- nClus[0] = 1 ;   nHits[0] = 0 ;                           // ITS - pixel
- nClus[1] = 1 ;   nHits[1] = 0 ;  
- nClus[2] = 1 ;   nHits[2] = 0 ;                           // ITS - drift
- nClus[3] = 1 ;   nHits[3] = 0 ;  
- nClus[4] = 1 ;   nHits[4] = 0 ;                           // ITS - strips
- nClus[5] = 1 ;   nHits[5] = 0 ;  
- nClus[6] = 160 ; nHits[6] = 0 ;                           // TPC
- nClus[7] = 130 ; nHits[7] = 0 ;                           // TRD
- nClus[8] = 1 ;   nHits[8] = 0 ;                           // TOF
+ nClus[0] = 1 ;   nHits[0] = 1 ;                           // ITS - pixel
+ nClus[1] = 1 ;   nHits[1] = 1 ;  
+ nClus[2] = 1 ;   nHits[2] = 1 ;                           // ITS - drift
+ nClus[3] = 1 ;   nHits[3] = 1 ;  
+ nClus[4] = 1 ;   nHits[4] = 1 ;                           // ITS - strips
+ nClus[5] = 1 ;   nHits[5] = 1 ;  
+ nClus[6] = 160 ; nHits[6] = 1 ;                           // TPC
+ nClus[7] = 130 ; nHits[7] = 1 ;                           // TRD
+ nClus[8] = 1 ;   nHits[8] = 1 ;                           // TOF
 
  Int_t pdgcode = 0 ;
  Float_t dEdx[4] ; for(Int_t de=0;de<4;de++) { dEdx[de] = -1. ; }
@@ -439,9 +421,9 @@ AliFlowV0* AliFlowKineMaker::FillFlowV0(TParticle* fParticle)
  fFlowV0->SetVmass((Float_t)fParticle->GetMass()) ; 
  
  // daughters (should be taken on puprose from the KineTree, and wrote into the flow event)
- Int_t nDaughters = fParticle->GetNDaughters() ;
- Int_t d1 = fParticle->GetDaughter(nDaughters-1) ;
- Int_t d2 = fParticle->GetDaughter(nDaughters-2) ;
//Int_t nDaughters = fParticle->GetNDaughters() ;
//Int_t d1 = fParticle->GetDaughter(nDaughters-1) ;
//Int_t d2 = fParticle->GetDaughter(nDaughters-2) ;
 //
 // AliFlowTrack* pos = (AliFlowTrack*)fFlowEvent->TrackCollection()->At(pN) ; 
 // AliFlowTrack* neg = (AliFlowTrack*)fFlowEvent->TrackCollection()->At(nN) ; 
index f8fd38e850444c02867d9ca125aa1b30d4e5306e..29311e88437a0dc2cd4140f69f4b97b6ee29137e 100644 (file)
@@ -7,8 +7,8 @@
 //////////////////////////////////////////////////////////////////////
 //
 // Description: parser class from KineTree (pure MC simulation) to 
-//  AliFlowEvent . Nothing else to say at this point, but 3 lines of 
-//  comments (at least) must be there to make the code checker happy.
+//  AliFlowEvent . It does not use the AliRunLoades, but simply 
+//  gets the KineTree as an imput (a macro mast provide them).
 //
 //////////////////////////////////////////////////////////////////////
 
index e041be941436f4f9a8e61caf42e309413984db25..f4f23fe860a43cb0bdd67965b28cbbeb8227b7d9 100644 (file)
@@ -41,6 +41,8 @@
 
 // ANSI things
 #include <stdlib.h>
+#include <vector>
+
 using namespace std; //required for resolving the 'cout' symbol
 
 ClassImp(AliFlowMaker) 
@@ -48,8 +50,8 @@ ClassImp(AliFlowMaker)
 AliFlowMaker::AliFlowMaker():
   fEventNumber(0), fTrackNumber(0), fV0Number(0), fGoodTracks(0), fGoodV0s(0),
   fGoodTracksEta(0), fPosiTracks(0), fNegaTracks(0), fUnconstrained(0),
-  fSumAll(0), fCutEvts(0), fCutTrks(0), fCutV0s(0), fNewAli(kFALSE), 
-  fLoopTrks(kTRUE), fLoopV0s(kTRUE), fCounter(0), 
+  fSumAll(0), fCutEvts(0), fCutTrks(0), fCutV0s(0), fCounter(0), fMovedTr(0x0),
+  fNewAli(kFALSE), fLoopTrks(kTRUE), fLoopV0s(kTRUE),
   fESD(0x0), fTrack(0x0), fV0(0x0), fVertex(0x0),
   fRunID(0), fNumberOfEvents(0), fNumberOfTracks(0), 
   fNumberOfV0s(0), fMagField(0), 
@@ -78,7 +80,7 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
  // It loops on track & v0 and calls the methods to fill the arrays . 
  // ... . 
 
- fFlowEvent = new AliFlowEvent() ; if(!fFlowEvent) { return 0 ; }
+ fFlowEvent = new AliFlowEvent(10000) ; if(!fFlowEvent) { return 0 ; }
  //cout << " -evt- " << fFlowEvent << endl ;
 
  fRunID = fESD->GetRunNumber() ;
@@ -88,6 +90,9 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
  fNumberOfV0s = fESD->GetNumberOfV0s() ;
  //
  cout << " *evt n. " << fEventNumber << " (run " << fRunID << ")  -  tracks: " << fNumberOfTracks << " ,   v0s " << fNumberOfV0s << endl ;
+ // Clean the vector of links esd-flowEvt
+ fMovedTr.clear(); // Remove all elements
 
  // Event id 
  fFlowEvent->SetRunID(fRunID) ;               
@@ -130,8 +135,9 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
    {
     FillFlowTrack(fTrack) ;   
     fGoodTracks++ ;                                  
+    fMovedTr.push_back(fFlowEvent->TrackCollection()->GetLast()) ; 
    }
-   else { badTrks++ ; continue ; }
+   else { fMovedTr.push_back(-1) ; badTrks++ ; continue ; }
   }
   fCutTrks += badTrks ;
  } // cout << " -track number- :  " << fTrackNumber << endl ;
@@ -218,7 +224,7 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
   fFlowTrack->SetEta(eta) ;                            
  
   // number of constrainable tracks with |eta| < AliFlowConstants::fgEtaGood (0.9)
-  if(TMath::Abs(eta) < AliFlowConstants::fgEtaGood)  { fGoodTracksEta++ ; }
+  if(TMath::Abs(eta) < AliFlowConstants::fgEtaMid)  { fGoodTracksEta++ ; }
  }
  else  // in case Constriction impossible for track, fill the UnConstrained (global)
  {
@@ -428,9 +434,7 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  // daughters 
  Int_t pN = fV0->GetPindex() ;
  Int_t nN = fV0->GetNindex() ;
- AliFlowTrack* pos = (AliFlowTrack*)fFlowEvent->TrackCollection()->At(pN) ; 
- AliFlowTrack* neg = (AliFlowTrack*)fFlowEvent->TrackCollection()->At(nN) ; 
- fFlowV0->SetDaughters(pos,neg) ;
+ fFlowV0->SetDaughters(fMovedTr[pN],fMovedTr[nN]) ;
 
  return fFlowV0 ;
 }
@@ -439,6 +443,8 @@ Bool_t AliFlowMaker::CheckTrack(AliESDtrack* fTrack) const
 {
  // applies track cuts (pE , nHits , label)
 
+ if(!fTrack) { return kFALSE ; }
+
  Int_t idXt[180] ;  // used for Cluster Map ( see AliESDtrack::GetTPCclusters() )
  Int_t   nHits = fTrack->GetTPCclusters(idXt) ;
  Float_t pE    = fTrack->GetP() ;
@@ -454,9 +460,17 @@ Bool_t AliFlowMaker::CheckTrack(AliESDtrack* fTrack) const
 //-----------------------------------------------------------------------
 Bool_t AliFlowMaker::CheckV0(AliESDv0* fV0) const
 {
- // applies v0 cuts (dummy)
+ // applies v0 cuts (mass>fElow, daughters included in the tracks)
  
  if(!fV0) { return kFALSE ; }
+ Int_t pN = fV0->GetPindex() ;
+ Int_t nN = fV0->GetNindex() ;
+ Float_t iMass = (Float_t)fV0->GetEffMass() ;
+ if(iMass < fElow)      { return kFALSE ; }
+ if(fMovedTr[pN] < 0)   { return kFALSE ; }
+ if(fMovedTr[nN] < 0)   { return kFALSE ; }
 
  return kTRUE ;
 }
@@ -487,6 +501,10 @@ void AliFlowMaker::PrintCutList()
  { 
   cout << "  Track Energy (P_total) [ " << fElow << " , " << fEup << " ] " << endl ; 
  }
+ if(fElow>0.)
+ { 
+  cout << "  V0 invariant mass > " << fElow << endl ; 
+ }
  cout << " *               * " << endl ;
 }
 //-----------------------------------------------------------------------
index d94486ae3aa1adae408ae800b5e6127f4861a8c1..cdc8557410a8a7bc34cd819d5d95c13a2f5f3734 100644 (file)
@@ -15,6 +15,9 @@
 #ifndef ALIFLOWMAKER_H
 #define ALIFLOWMAKER_H
 
+#include <vector>
+using namespace std; //required for resolving the 'cout' symbol
+
 class AliFlowEvent ;
 class AliFlowTrack ;
 class AliFlowV0 ;
@@ -62,6 +65,10 @@ class AliFlowMaker  {
     Int_t          GetBayesian(Int_t i = 2) const          { return fBayesianAll[i] ; }
     Float_t        GetBayesianNorm(Int_t i = 2) const      { return (Float_t)fBayesianAll[i] / (Float_t)fSumAll ; }
 
+  // Flags
+    void           DoTracks(Bool_t dt = kTRUE)             { fLoopTrks = dt ; }    // loop over tracks 
+    void           DoV0s(Bool_t dv = kTRUE)                { fLoopV0s = dv ; }     // loop over v0s 
+
  protected:
  
   // enumerators                           
@@ -81,14 +88,15 @@ class AliFlowMaker  {
     Int_t            fCutEvts ;                            //! total enumerator for discarded events
     Int_t            fCutTrks ;                            //! total enumerator for discarded tracks
     Int_t            fCutV0s ;                             //! total enumerator for discarded V0s
+
+    Int_t           fCounter ;                             //! number of processed events
+    vector<int>      fMovedTr ;                             //! tracks wich number has been changed (for cutting away something)
  
   // Flags
     Bool_t           fNewAli ;                             //! enables the new ESD features (since AliRoot 12/2006) 
     Bool_t           fLoopTrks ;                           //! flag to loop over tracks 
     Bool_t           fLoopV0s ;                            //! flag to loop over v0s 
 
-    Int_t           fCounter ;                             //! number of processed events
-
  private:
 
   // to make the code checker happy
@@ -114,8 +122,8 @@ class AliFlowMaker  {
 
   // Tracks cuts
     Int_t   fNHits;                                                // exclude tracks with less than .. TPC hits 
-    Float_t fElow ;                                        // exclude tracks below .. GeV (~total Momentum)
-    Float_t fEup ;                                         // exclude tracks above .. GeV (~total Momentum)
+    Float_t fElow ;                                        // exclude tracks with total Momentum < .. GeV & v0 with mass < .. GeV
+    Float_t fEup ;                                         // exclude tracks with total Momentum > .. GeV
     Int_t   fLabel[2] ;                                            // exclude tracks outside label interval
  
   ClassDef(AliFlowMaker,0);
index 70d0ce64101b17811c55969faa7b88649caee645..17c3e75cc39534fc3963fa289e2cccfaf674b537 100644 (file)
@@ -52,7 +52,6 @@ AliFlowSelection::AliFlowSelection():
 {
  // Default constructor: when initialized all selection cuts are disabled (lo>hi).
 
- // -
  fPidPart[0] = '\0' ;
  fPidProbPart[0]       = 1 ;           // = 0.  
  fPidProbPart[1]       = 0 ;           // = 1.  
@@ -79,7 +78,6 @@ AliFlowSelection::AliFlowSelection():
  fYPart[0]            = 1 ;            // = 0.  
  fYPart[1]            = 0 ;            // = 0.  
  // -
- fV0Pid[10] = '\0' ;
  fV0Pt[0]             = 1 ;  
  fV0Pt[1]             = 0 ;  
  fV0P[0]              = 1 ;  
@@ -201,7 +199,7 @@ Bool_t AliFlowSelection::SelectPart(AliFlowTrack* pFlowTrack) const
  float globdca = pFlowTrack->Dca();
  if(fDcaGlobalPart[1] > fDcaGlobalPart[0] && (globdca < fDcaGlobalPart[0] || globdca > fDcaGlobalPart[1])) return kFALSE;
  
- // DCA Global
+ // DCA / error
  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;
@@ -219,21 +217,6 @@ Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0) const
  // to correlate with the event plane).  
  // Returns kTRUE if the v0 is selected.
 
- // PID
- if(fV0Pid[0] != '\0') 
- {
-  if(strstr(fV0Pid, '\0')!=0)
-  {
-   int charge = pFlowV0->Charge();
-   if(strcmp("0", fV0Pid)==0 && charge != 0) return kFALSE;
-  } 
-  else 
-  {
-   const Char_t* pid = pFlowV0->Pid() ;
-   if(strstr(pid, fV0Pid)==0) return kFALSE;
-  }
- }
-
  // InvMass
  float mass = pFlowV0->Mass() ;
  if(fV0Mass[1]>fV0Mass[0])
@@ -283,6 +266,17 @@ Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0) const
  float y = pFlowV0->Y();
  if(fV0Y[1] > fV0Y[0] && (y < fV0Y[0] || y > fV0Y[1])) return kFALSE;
 
+//  // PID (useless)
+//  if(fV0Pid[0] != '\0')
+//  {
+//   int numPid = TMath::Abs(pFlowV0->MostLikelihoodPID()) ;
+//   if((fV0Pid = "gamma") && (fMostLikelihoodPID != 22))          { return kFALSE ; }
+//   else if((fV0Pid = "K0") && (fMostLikelihoodPID != 311))       { return kFALSE ; }
+//   else if((fV0Pid = "K0s") && (fMostLikelihoodPID != 310))      { return kFALSE ; }
+//   else if((fV0Pid = "K0l") && (fMostLikelihoodPID != 130))      { return kFALSE ; }
+//   else if((fV0Pid = "Lambda0") && (fMostLikelihoodPID != 3122)) { return kFALSE ; }
+//  }
+
  return kTRUE;
 }
 //-----------------------------------------------------------------------
@@ -374,8 +368,7 @@ void AliFlowSelection::PrintV0List() const
  cout << "#################################################################" << endl;
  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 ; }
+ // if(fV0Pid[0]!='\0') { cout << "# P.id for V0s correlated to the event plane: " << fV0Pid << "  " << endl ; }
  if(fV0Mass[1]>fV0Mass[0]) 
  {
   if(!fV0SideBand)
index 1866619399a32fc344a7fa0d340f4803a64dc4a7..cddb277d2ef1e684e2496498f52120704af65ab8 100644 (file)
 
 #include "TObject.h"
 #include "TMath.h"
-
 #include "AliFlowConstants.h"
 
+
 class AliFlowTrack ;
 class AliFlowV0 ;
 class AliFlowEvent ;
-class AliFlowConstants ;
 
 class AliFlowSelection : public TObject {
 
@@ -107,7 +106,6 @@ class AliFlowSelection : public TObject {
   void    SetDcaGlobalPart(Float_t lo, Float_t hi)     { fDcaGlobalPart[0] = lo; fDcaGlobalPart[1] = hi; }                  // Sets d.c.a. 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 
   void    SetV0P(Float_t lo, Float_t hi)              { fV0P[0] = lo ; fV0P[1] = hi; }                                      // Sets Momentum for v0 wrt plane 
@@ -120,6 +118,7 @@ class AliFlowSelection : public TObject {
   void    SetV0LenghtOverSigma(Float_t lo, Float_t hi) { fV0LenghtOverSigma[0] = lo ; fV0LenghtOverSigma[1] = hi; }         // Sets closest approach (between the 2 daughter tracks) for v0 wrt plane  
   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    SetV0Pid(const Char_t* pid)                       { strncpy(fV0Pid, pid, 9) ; fV0Pid[9] = '\0' ; }                      // Sets PID for v0 wrt plane (...)
 
   void    SetPtBinsPart(Int_t bins)                   { fPtBinsPart = bins; }                                               // Sets N. of bins from fPtPart[0] to fPtPart[1]                
 
@@ -138,7 +137,6 @@ class AliFlowSelection : public TObject {
   Int_t  fRun ;                                                // Run number 
 
  // Cuts for V0 correlated to the Raction Plane (new)
-  Char_t  fV0Pid[10];                                          // PID for v0 wrt plane (...)
   Float_t fV0SideBand ;                                                // width of the sidebands (using the sidebands' candidates)
   Float_t fV0Mass[2] ;                                         // mass cut for v0 wrt plane
   Float_t fV0Pt[2];                                            // pT for v0 wrt plane 
@@ -150,6 +148,7 @@ class AliFlowSelection : public TObject {
   Float_t fV0Lenght[2];                                        // distance to the main vertex for v0 wrt plane
   Float_t fV0LenghtOverSigma[2];                               // distance to the main vertex in sigma units for v0 wrt plane
   Float_t fV0DcaCross[2];                                      // closest approach (between the 2 daughter tracks) for v0 wrt plane
+  //Char_t  fV0Pid[10];                                        // PID for v0 wrt plane (...)
 
  // Cuts for Tracks that will be related to the Raction Plane (original strategy from STAR)
   Char_t  fPidPart[10];                                        // PID for parts. wrt plane (h+, h-, pi-, pi+, pi, k+, k-, k, pr+, pr-, pr, d+, d-, d, e+, e-, e)
index 8284f1f3580d0f64c2923301ec7039236936a766..ac092580cb39f36345562ae64741c552a475f0fb 100644 (file)
@@ -26,17 +26,17 @@ using namespace std; //required for resolving the 'cout' symbol
 ClassImp(AliFlowV0) 
 //////////////////////////////////////////////////////////////////////////////
 AliFlowV0::AliFlowV0():
 fPhi(0.), fPt(0.), fEta(0.), fChi2(0.), fMass(0.), fDca(0.), fCrossDCA(0.), fSigma(1.), fLabel(0), fMostLikelihoodPID(0), fPointAngle(0.),
-fDaughterP(0x0), fDaughterN(0x0)
+ fPhi(0.), fPt(0.), fEta(0.), fChi2(0.), fMass(0.), fDca(0.), fCrossDCA(0.), fSigma(1.), fLabel(0), fMostLikelihoodPID(0), fPointAngle(0.),
+ fDaughterP(-1), fDaughterN(-1)
 {
  // default constructor  
   for(Int_t dd=0;dd<3;dd++) { fCrossPoint[dd] = 0. ; }
// fDaughterP = 0  ; fDaughterN = 0  ;
 // fDaughterP = -1  ; fDaughterN = -1  ;
 }
 //////////////////////////////////////////////////////////////////////////////
 AliFlowV0::AliFlowV0(const Char_t* name):
 fPhi(0.), fPt(0.), fEta(0.), fChi2(0.), fMass(0.), fDca(0.), fCrossDCA(0.), fSigma(1.), fLabel(0), fMostLikelihoodPID(0), fPointAngle(0.),
-fDaughterP(0x0), fDaughterN(0x0)
+ fPhi(0.), fPt(0.), fEta(0.), fChi2(0.), fMass(0.), fDca(0.), fCrossDCA(0.), fSigma(1.), fLabel(0), fMostLikelihoodPID(0), fPointAngle(0.),
+ fDaughterP(-1), fDaughterN(-1)
 {
  // TNamed constructor 
  
@@ -67,7 +67,7 @@ Float_t  AliFlowV0::Y() const
  // Rapidity of the v0
 
  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. ; }
+ else if(TMath::Abs((Float_t)P()) < TMath::Abs((Float_t)Pt())) { cout << "v0: " << GetName() << " has  Pt() > P() !!!" << endl ; return -1000. ; }
  // -
  Float_t mass = Mass() ; 
  Double_t pz = TMath::Sqrt(P()*P() - Pt()*Pt()); 
@@ -96,17 +96,17 @@ const char* AliFlowV0::Pid() const
  return pId.Data() ; 
 }
 //////////////////////////////////////////////////////////////////////////////
-void AliFlowV0::SetPid(const Char_t* pid)              
-{ 
- // 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  ; }
- else if(strstr(pid,"K0s"))     { fMostLikelihoodPID = 310  ; }
- else if(strstr(pid,"K0l"))     { fMostLikelihoodPID = 130  ; }
- else if(strstr(pid,"Lambda0")) { fMostLikelihoodPID = 3122 ; }
- // ...
- else { fMostLikelihoodPID = 0 ; cout << "AliFlowV0 - !BAD IMPUT!" << endl ; }
-}
+// void AliFlowV0::SetPid(const Char_t* pid)           
+// 
+//  // 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  ; }
+//  else if(strstr(pid,"K0s"))     { fMostLikelihoodPID = 310  ; }
+//  else if(strstr(pid,"K0l"))     { fMostLikelihoodPID = 130  ; }
+//  else if(strstr(pid,"Lambda0")) { fMostLikelihoodPID = 3122 ; }
+//  // ...
+//  else { fMostLikelihoodPID = 0 ; cout << "AliFlowV0 - !BAD IMPUT!" << endl ; }
+// }
 //////////////////////////////////////////////////////////////////////////////
index 4a7985219cbdfbcb8b56748ec59f651fb2c5cc40..93addeb6c3c3e6cbc6e6e969e73cd04470df258c 100644 (file)
@@ -44,8 +44,8 @@ public:
   Float_t       Dca()          const { return fDca ; }
   Float_t       Chi2()         const { return fChi2; }
   Float_t       Mass()         const { return fMass ; }
-  AliFlowTrack* DaughterP()    const { return fDaughterP ; } 
-  AliFlowTrack* DaughterN()    const { return fDaughterN ; } 
+  Int_t         DaughterP()    const { return fDaughterP ; } 
+  Int_t         DaughterN()    const { return fDaughterN ; } 
   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] ; }
@@ -58,7 +58,6 @@ public:
   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)             { fPhi = phi; }   
   void SetEta(Float_t eta)             { fEta = eta; }   
   void SetPt(Float_t pt)               { fPt = pt; }     
@@ -71,7 +70,7 @@ public:
   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) { fDaughterP = pos ; fDaughterN = neg ; }
+  void SetDaughters(Int_t pos, Int_t neg)                { fDaughterP = pos ; fDaughterN = neg ; }
 
 
 private:
@@ -93,8 +92,8 @@ private:
   Int_t        fLabel ;                        // Label of the V0 (link: KineTree-ESD) 
   Int_t        fMostLikelihoodPID;             // most probable P.Id. hypotesis
   Float_t      fPointAngle;                    // cosine of the pointing angle
-  AliFlowTrack* fDaughterP ;                   // daughter tracks (pointers to the TracksCollection())
-  AliFlowTrack* fDaughterN ;                   // daughter tracks (pointers to the TracksCollection())
+  Int_t         fDaughterP ;                   // positive daughter track (position in the TracksCollection())
+  Int_t         fDaughterN ;                   // negative daughter track (position in the TracksCollection())
   
   ClassDef(AliFlowV0,2) ;                      // macro for rootcint
 };
index 4a48047d32457282b670fa8c06f4c3c7319156d0..5b6d7292ab1585db98b3bf4d1044d6e545b04d8a 100644 (file)
@@ -27,7 +27,6 @@ class AliFlowTrack;
 class AliFlowV0;
 class AliFlowEvent;
 class AliFlowSelection;
-class AliFlowConstants;
 
 class AliFlowWeighter {
 
index 9efe93437686ef6e4cce6be85ac44e0568f74626..487420dae60967a24b704ebf9111a16eb090035c 100644 (file)
@@ -172,19 +172,19 @@ void AliSelectorFoF::Begin(TTree*)
   // R.P. calculation cuts
   for(int j=0;j<AliFlowConstants::kHars;j++)
   {
-   fFlowSelect->SetEtaCut(0., 1.1, j, 1) ;
+   fFlowSelect->SetEtaCut(0., 0.9, j, 1) ;
    fFlowSelect->SetPtCut(0.1, 10. , j, 1);
   }
   fFlowSelect->SetConstrainCut(kTRUE) ;
   fFlowSelect->SetDcaGlobalCut(0.,0.1);
   // Correlation analysis cuts (not all of them)
-  fFlowSelect->SetEtaPart(-1.1,1.1);
+  fFlowSelect->SetEtaPart(-0.9,0.9);
   fFlowSelect->SetPtPart(0.1,10.);
   fFlowSelect->SetConstrainablePart(kTRUE);
   fFlowSelect->SetDcaGlobalPart(0.,0.1);
   // V0 analysis cuts (not all of them ... they are useless anyway)
   fFlowSelect->SetV0Mass(0.4875,0.5078) ;       // Mk0 = 0.49765
-  fFlowSelect->SetV0SideBands(0.08) ;
+  fFlowSelect->SetV0SideBands(0.1) ;
   fFlowSelect->SetV0Pt(0.1,10.) ;
   fFlowSelect->SetV0Eta(-2.1,2.1) ;
   // print list :
@@ -231,7 +231,7 @@ void AliSelectorFoF::Begin(TTree*)
 
   // Analysis settings
    fFlowAnal->SetFlowForV0() ;         // default kTRUE.
-   fFlowAnal->SetEtaSub() ;            // default kFALSE
+   fFlowAnal->SetSub(1) ; //eta  // ->SetChrSub() ; //charge  // ->SetRndSub() ; //random (default)
    //fFlowAnal->SetV1Ep1Ep2() ;          // default kFALSE.
    //fFlowAnal->SetShuffle() ;           // default kFALSE. shuffles track array
    //fFlowAnal->SetRedoWgt();           // default kFALSE. recalculates phiWgt (even if phiWgt file is already there)
index c63ff64be83f1242b872e63e852e68e0d96bdb5f..cb4de59aa440ac49b6624f34c078080b7661ac8e 100644 (file)
@@ -6,13 +6,13 @@
 #define ALISELECTORFOF_H
 
 #include <TSelector.h>
+#include "AliFlowConstants.h"
 
 class AliFlowEvent;
 class AliFlowSelection;
 class AliFlowMaker;
 class AliFlowAnalyser; 
 class AliFlowWeighter;
-class AliFlowConstants;
 
 class AliESD;
 class AliESDtrack;
index 0682cb197b78cdc2174dba522cd5f6db44840db2..4d9f006cbecd812173c56f6c7308f3ed9af48d1d 100755 (executable)
@@ -15,28 +15,33 @@ echo " "
 export ALIFLOW=`pwd`
 
 rm *.so 
+rm flowDict.*
 
-rootcint -f AliFlowTrack_root.cxx -c  -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowTrack.h
-rootcint -f AliFlowV0_root.cxx -c  -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowV0.h
-rootcint -f AliFlowSelection_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowSelection.h
-rootcint -f AliFlowEvent_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowEvent.h
-rootcint -f AliFlowConstants_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowConstants.h
-rootcint -f AliFlowMaker_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowMaker.h 
-rootcint -f AliFlowAnalyser_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowAnalyser.h
-rootcint -f AliFlowWeighter_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowWeighter.h
-rootcint -f AliFlowKineMaker_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowKineMaker.h 
+# rootcint -f AliFlowTrack_root.cxx -c     -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowTrack.h      ../PWG2flowLinkDef.h
+# rootcint -f AliFlowV0_root.cxx -c        -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowV0.h         ../PWG2flowLinkDef.h
+# rootcint -f AliFlowSelection_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowSelection.h  ../PWG2flowLinkDef.h
+# rootcint -f AliFlowEvent_root.cxx -c     -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowEvent.h      ../PWG2flowLinkDef.h
+# rootcint -f AliFlowConstants_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowConstants.h  ../PWG2flowLinkDef.h
+# rootcint -f AliFlowMaker_root.cxx -c     -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowMaker.h      ../PWG2flowLinkDef.h
+# rootcint -f AliFlowAnalyser_root.cxx -c  -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowAnalyser.h   ../PWG2flowLinkDef.h
+# rootcint -f AliFlowWeighter_root.cxx -c  -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowWeighter.h   ../PWG2flowLinkDef.h
+# rootcint -f AliFlowKineMaker_root.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlowKineMaker.h    ../PWG2flowLinkDef.h
+
+rootcint -f flowDict.cxx -c -I$ALICE_ROOT/include -I$ROOTSYS/include AliFlow*.h ../PWG2flowLinkDef.h
 
 echo "                                                          code CINTed"
 
 echo ""
-#g++ -Wall -shared -I$ROOTSYS/include -o AliFlow_Pure.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowConstants*.cxx 
+#gcc -Wall -shared -I$ROOTSYS/include -o AliFlow_Pure.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowConstants*.cxx 
 #echo "                                <ALIFLOW_PURE.SO>          for ROOT compiled"
-#g++ -Wall -shared -g -I$ALICE_ROOT/include -I$ROOTSYS/include -o AliFlow_Mak.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowMaker*.cxx AliFlowConstants*.cxx 
+#gcc -Wall -shared -g -I$ALICE_ROOT/include -I$ROOTSYS/include -o AliFlow_Mak.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowMaker*.cxx AliFlowConstants*.cxx 
 #echo "                                <ALIFLOW_MAK.SO>        for AliROOT compiled"
-#g++ -Wall -shared -g -I$ROOTSYS/include -o AliFlow_Ana.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowAnalyser*.cxx AliFlowWeighter*.cxx AliFlowConstants*.cxx 
+#gcc -Wall -shared -g -I$ROOTSYS/include -o AliFlow_Ana.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowAnalyser*.cxx AliFlowWeighter*.cxx AliFlowConstants*.cxx 
 #echo "                                <ALIFLOW_ANA.SO>           for ROOT compiled"
-g++ -Wall -shared -g -I$ALICE_ROOT/include -I$ROOTSYS/include -o AliFlow_All.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowMaker*.cxx AliFlowAnalyser*.cxx AliFlowWeighter*.cxx AliFlowConstants*.cxx AliFlowKineMaker*.cxx 
-echo "                         <ALIFLOW_ALL.SO>        for AliROOT compiled"
+#gcc -Wall -shared -g -I$ALICE_ROOT/include -I$ROOTSYS/include -o AliFlow_All.so AliFlowTrack*.cxx AliFlowV0*.cxx AliFlowSelection*.cxx AliFlowEvent*.cxx AliFlowMaker*.cxx AliFlowAnalyser*.cxx AliFlowWeighter*.cxx AliFlowConstants*.cxx AliFlowKineMaker*.cxx 
+#echo "                                <ALIFLOW_ALL.SO>        for AliROOT compiled"
+gcc -Wall -shared -g -I$ALICE_ROOT/include -I$ROOTSYS/include -o AliFlow_New.so AliFlowTrack.cxx AliFlowV0.cxx AliFlowSelection.cxx AliFlowEvent.cxx AliFlowMaker.cxx AliFlowAnalyser.cxx AliFlowWeighter.cxx AliFlowConstants.cxx AliFlowKineMaker.cxx flowDict.cxx 
+echo "                         <ALIFLOW_NEW.SO>        for AliROOT compiled"
 
 rm AliFlowTrack_root.*
 rm AliFlowV0_root.*          
@@ -44,10 +49,12 @@ rm AliFlowSelection_root.*
 rm AliFlowEvent_root.*      
 rm AliFlowConstants_root.* 
 rm AliFlowMaker_root.*     
-rm AliFlowKineMaker_root.*     
 rm AliFlowAnalyser_root.* 
 rm AliFlowWeighter_root.* 
+rm AliFlowKineMaker_root.*  
 
+rm flowDict.*
+   
 echo ""
 echo ""
 echo "                                                                    done."
diff --git a/PWG2/FLOW/macros/docMaker.C b/PWG2/FLOW/macros/docMaker.C
new file mode 100644 (file)
index 0000000..14f56fd
--- /dev/null
@@ -0,0 +1,18 @@
+{
+ gSystem->Load("libPhysics.so") ;
+ gSystem->Load("libPWG2flow.so") ;
+ THtml gd ;  
+ char *htmlPath = gSystem->ExpandPathName("$ALICE_ROOT/PWG2/FLOW/htmldoc/.") ;
+ gd.SetOutputDir(htmlPath) ;
+ gd.MakeClass("AliFlowConstants") ;
+ gd.MakeClass("AliFlowTrack") ;
+ gd.MakeClass("AliFlowEvent") ;
+ gd.MakeClass("AliFlowV0") ;
+ gd.MakeClass("AliFlowSelection") ;
+ gd.MakeClass("AliFlowMaker") ;
+ gd.MakeClass("AliFlowKineMaker") ;
+ gd.MakeClass("AliFlowWeighter") ;
+ gd.MakeClass("AliFlowAnalyser") ;
+// gd.MakeClass("AliFlow...") ;
+// gd.MakeIndex() ;
+}
diff --git a/PWG2/FLOW/macros/efficiency2s.C b/PWG2/FLOW/macros/efficiency2s.C
new file mode 100644 (file)
index 0000000..d577284
--- /dev/null
@@ -0,0 +1,416 @@
+/////////////////////////////////////////////////////////////
+//
+// $Id$
+//
+// Author: Emanuele Simili
+//
+/////////////////////////////////////////////////////////////
+//
+// Description: AliRoot macro to make AliFlowEvents from KineTree (new way) 
+//
+/////////////////////////////////////////////////////////////
+
+#include <vector>
+#include <iostream>
+#include <fstream>
+#include "TMath.h"
+#include "TH2.h"
+#include "TFile.h"
+#include "TObjArray"
+#include "TStopwatch.h"
+//#include "AliESD.h"
+
+using namespace std; //required for resolving the 'cout' symbol
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const char* aDataDir = "./" ; 
+Int_t aRuns = -1 ; Int_t offset = -1 ;
+
+AliRunLoader*  rl = 0 ;
+AliRun*    gAlice = 0 ;
+TTree*      treeK = 0 ;
+AliStack*  kStack = 0 ;
+TChain*  esdChain = 0 ;
+
+TTree* kOpen(int evtN=0) ;
+Int_t  kInit(const char* dir="./") ;
+
+Double_t Norm(Double_t nu[3]) ; 
+Double_t Phi(Double_t nu[3]) ;
+Double_t Pt(Double_t nu[3]) ;
+Double_t Eta(Double_t nu[3]) ;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+int efficiency2s()
+{
+ cout << " . Here the efficiency2 things ... " << endl ;
+ cout << endl ;
+
+ TStopwatch timer ;
+ timer.Start() ;
+
+// global settings, counters and pointers ...
+
+ int binPt = 100 ;                // bins in pT 
+ int binEta = 42 ;                // bins in eta 
+ float maxPt  = 5. ;              // max pT
+ float maxEta = 2.1 ;             // max eta
+ float pTbinWidth = maxPt/binPt ; // bin width (to quantify the smearing of pT)
+
+ const Int_t kCode[6] = {11,13,211,321,2212,10010020} ;  // stable particles
+  
+ int countsim = 0 ;               // number of simulations (esd files or folders)
+ int countev = 0 ;                // total number of looped events
+ int tot = 0 ;                    // total number of looped esd tracks
+ int totPerf = 0 ;                // total number of perfectly reconstructed tracks (in cut + mc primary + same bin)
+
+ AliESD*       esd = 0 ;          // Event Summary Data
+ AliESDtrack*  esdTrack = 0 ;     // reconstructed track
+ TParticle*    particle = 0 ;     // TParticle (kineTree)
+ TParticlePDG* particlePDG = 0 ;  // TParticlePDG (type, charge, etc.)
+ //TString       esdFileName("AliESDs.root") ;
+ //TString       gAliceName("galice.root") ;
+  
+// define the structs ...
+
+ struct structSameBin 
+ { 
+  TH2F* hYield2Desd ;
+  TH2F* hYield2Dmc ;
+  
+  TH2F* hPtPt ;
+  TH2F* hEtaEta ;
+  TH2F* hPhiPhi ;
+ } ;
+ struct structMcPrim { struct structSameBin histSameBin[2] ; } ;
+ struct structEsdIn  { struct structMcPrim histMcPrim[2] ; } ;
+ struct structEsdIn  histEsdIn[2] ;
+// define the histograms ...
+
+ TString histTitle ;
+ for(int i = 0; i < 2; i++)
+ {
+  for(int j = 0; j < 2; j++) 
+  {
+   for(int k = 0; k < 2; k++)
+   {
+    TString histDetails ;
+    if(i) { histDetails = "_inCut"    ; } else { histDetails = "_outCut"   ; }
+    if(j) { histDetails += "_mcPrim"  ; } else { histDetails += "_mcSec"   ; }
+    if(k) { histDetails += "_sameBin" ; } else { histDetails += "_diffBin" ; }
+    
+   // Yield pt - eta
+    histTitle = "hYield2Desd" ; histTitle += histDetails ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Desd = new TH2F(histTitle.Data(), histTitle.Data(), binEta, -maxEta, maxEta, binPt, 0., maxPt);
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Desd->Sumw2();
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Desd->SetXTitle("#eta");
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Desd->SetYTitle("p_{T} (GeV/c)");
+
+   // Yield pt - eta
+    histTitle = "hYield2Dmc" ; histTitle += histDetails ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Dmc = new TH2F(histTitle.Data(), histTitle.Data(), binEta, -maxEta, maxEta, binPt, 0., maxPt);
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Dmc->Sumw2();
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Dmc->SetXTitle("#eta");
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Dmc->SetYTitle("p_{T} (GeV/c)");
+
+   // comparison (esd vs kine)
+    histTitle = "hPtPt" ; histTitle += histDetails ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPtPt = new TH2F(histTitle.Data(), histTitle.Data(), binPt, 0., maxPt, binPt, 0., maxPt);
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPtPt->Sumw2();
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPtPt->SetXTitle("p_{T} (GeV/c) kine");
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPtPt->SetYTitle("p_{T} (GeV/c) esd");
+
+    histTitle = "hEtaEta" ; histTitle += histDetails ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hEtaEta = new TH2F(histTitle.Data(), histTitle.Data(), binEta, -maxEta, maxEta, binEta, -maxEta, maxEta);
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hEtaEta->Sumw2();
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hEtaEta->SetXTitle("#eta kine");
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hEtaEta->SetYTitle("#eta esd");
+
+    histTitle = "hPhiPhi" ; histTitle += histDetails ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPhiPhi = new TH2F(histTitle.Data(), histTitle.Data(), 180, 0., 360., 180, 0., 360.);
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPhiPhi->Sumw2();
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPhiPhi->SetXTitle("#phi kine");
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPhiPhi->SetYTitle("#phi esd");
+
+    // delete histTitle ; delete histDetails ;
+   }
+  }
+ }
+
+//  TH2F* pTpT = new TH2F("", "", 20, -2., 2., 30, 0., 3.);
+//  ->Sumw2();
+//  ->SetXTitle("Pt (GeV/c)");
+//  ->SetYTitle("Pt (GeV/c)");
+
+// loop (more simulations) ...
+
+ TString execDir(gSystem->pwd());
+ TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
+ TList* dirList           = baseDir->GetListOfFiles();
+ Int_t nDirs              = dirList->GetEntries();
+ gSystem->cd(execDir);
+ for (Int_t iDir=0; iDir<nDirs; ++iDir)
+ {
+  TSystemFile* presentDir = (TSystemFile*)dirList->At(iDir);
+  if(!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0) 
+  { continue ; }
+  if(offset > 0)  { --offset ; continue ; }
+  if(countsim == aRuns) { break ; }
+  TString presentDirName(aDataDir); 
+  presentDirName += presentDir->GetName();
+  presentDirName += "/"; 
+
+// initialise esdChain and kineTree ... 
+  
+  Int_t fNumberOfESDs      = eInit(presentDirName.Data()) ;
+  Int_t fNumberOfKineTrees = kInit(presentDirName.Data()) ;
+
+  Int_t fNumberOfEvents = -1 ;
+  if(fNumberOfKineTrees == fNumberOfESDs)  { fNumberOfEvents = fNumberOfKineTrees ; }
+  if(fNumberOfEvents < 0)                 { return fNumberOfEvents ; }
+
+  esdChain->SetBranchAddress("ESD",&esd) ;
+
+  cout << " Directory :  " << presentDirName << " ;  n. of events : " << fNumberOfEvents << endl ;
+  
+// loop (events) ...
+
+  for(int evtN=0;evtN<fNumberOfEvents;evtN++)   // use (1) for testing the folder loop
+  {
+   int countrk = 0 ;
+   int nConstrainable = 0 ;
+   int nPrimaries = 0 ;
+   int nPerfect = 0 ;
+   
+   treeK = kOpen(evtN) ;
+   treeK->SetBranchAddress("Particles",&particle) ;    // set the place where to put the TParticle from the tree (filled every time you call GetEntry() )
+  
+   esdChain->GetEntry(evtN) ;
+
+   Int_t fNumberOfParticles = treeK->GetEntries() ;
+   Int_t fNumberOfPrimaries = kStack->GetNprimary() ;   
+   Int_t fNumberOfTracks = esd->GetNumberOfTracks() ;
+
+   cout << " Event " << evtN << " has " << fNumberOfTracks << " tracks in the ESD, and " << fNumberOfParticles << " particles in the kinetree (" << fNumberOfPrimaries << " primaries) ." << endl ;
+  
+// loop (tracks) ...
+
+   float ptTr, ptP ;
+   float phiTr, phiP ;
+   float etaTr, etaP ;
+   Double_t cD[3] ; // for(Int_t iii=0;iii<3;iii++) { cD[iii] = 0 ; }                          
+   for(Int_t nTracks = 0; nTracks < fNumberOfTracks; nTracks++)  
+   {
+    esdTrack = esd->GetTrack(nTracks) ;
+    Int_t label = esdTrack->GetLabel() ;
+
+    Int_t idStack = TMath::Abs(label) ;              // (idStack) is just the label of the particle (refers to the stack)
+    Int_t idTree = kStack->TreeKEntry(idStack) ;      // the stack knows the position (idTree) of the particle (idStack) in the tree
+    treeK->GetEntry(idTree) ;                        // get the particle  (idTree) out of the tree
+    
+    // cout << "  Track " << nTracks << " has label = " << label << " and idTree = " << idTree << endl ;
+
+    Int_t incut   = 0 ; if(esdTrack->GetPxPyPz(cD))          { incut = 1 ; } 
+    Int_t primary = 0 ; if(particle->IsPrimary())            { primary = 1 ; }
+    Int_t perfect = 0 ; if(TMath::Abs(ptTr-ptP) < pTbinWidth) { perfect = 1 ; }
+
+    if(incut) { nConstrainable++ ; if(primary) { nPrimaries++ ; if(perfect) { nPerfect++ ; } } }
+
+   // Constrained pt, eta, phi from the ESDtrack ...
+    phiTr = (Float_t)Phi(cD) ; if(phiTr<0) { phiTr += 2*TMath::Pi() ; }
+    ptTr  = (Float_t)Pt(cD) ;  if(ptTr<=0) { cout << " !!! pt = " << ptTr << endl ; continue ; }
+    etaTr = (Float_t)Eta(cD) ;     
+   // Particle kinematic ...
+    phiP = particle->Phi() ;   if(phiP<0) { phiP += 2*TMath::Pi() ; }
+    ptP = particle->Pt();
+    etaP = particle->Eta();
+   // Pid ...
+    // particlePDG = particle->GetPDG() ;
+    // ...
+
+    histEsdIn[incut].histMcPrim[primary].histSameBin[perfect].hYield2Desd->Fill(etaTr,ptTr) ; 
+    histEsdIn[incut].histMcPrim[primary].histSameBin[perfect].hYield2Dmc->Fill(etaP,ptP) ; 
+    histEsdIn[incut].histMcPrim[primary].histSameBin[perfect].hPtPt->Fill(ptP,ptTr) ;
+    histEsdIn[incut].histMcPrim[primary].histSameBin[perfect].hEtaEta->Fill(etaP,etaTr) ;
+    histEsdIn[incut].histMcPrim[primary].histSameBin[perfect].hPhiPhi->Fill((180./TMath::Pi())*phiP,(180./TMath::Pi())*phiTr) ;
+    
+    // cout << " particle n. " << i << " mothers: " << particle->GetMother(0) << " , " << particle->GetMother(1) <<  endl ;    
+    //cout << "  Track " << nTracks << " has label = " << label << " and idTree = " << idTree << " is primary && constrainable " << endl ;
+    countrk++ ;
+   }
+
+   cout << " Event looped " << evtN << " - " << countrk << " tracks found: " << nConstrainable << " constrainable, of which " << nPrimaries << " primaries, and " << nPerfect << " perfectly reconstructed . " << endl ; cout << endl ; 
+   tot += countrk ;
+   totPerf += nPerfect ;            
+   countev++ ;
+  }    
+  esdChain->Reset() ; // delete esdChain ;
+  
+  //rl->UnloadgAlice() ; 
+  //rl->UnloadHeader() ; 
+  //rl->UnloadKinematics() ; 
+  rl->UnloadAll() ;
+  rl->RemoveEventFolder() ;
+  rl->Clear() ; // delete rl ;
+  
+  delete presentDir ;
+  countsim++ ;
+ }
+ cout <<  endl ;
+ cout << " Finished ... " << endl ;
+ cout << "  nEvts     :  " << countev << " in " << countsim << " simulations " << endl ;            
+ cout << "  nParticles:  " << tot << " (" << totPerf << " perfect) " << endl ;   
+ cout << " . " << endl ; 
+
+//  // plots ...
+// 
+//  TCanvas* vs = new TCanvas("vs","vs",900,400) ;
+//  vs->Divide(3,1) ;
+//  vs->cd(1) ; ...->Draw("COLZ") ;
+//  vs->cd(2) ; ...->Draw("COLZ") ;
+//  vs->cd(3) ; ...->Draw("COLZ") ;
+
+// break ;
+
+// output file ...
+
+ TString output("efficiency2s.root") ;
+ TFile * file = new TFile(output.Data(),"RECREATE") ;
+ file->cd() ; 
+ for(int i = 0; i < 2; i++)
+ {
+  for(int j = 0; j < 2; j++) 
+  {
+   for(int k = 0; k < 2; k++)
+   {
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Desd->Write() ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hYield2Dmc->Write() ; 
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPtPt->Write() ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hEtaEta->Write() ;
+    histEsdIn[i].histMcPrim[j].histSameBin[k].hPhiPhi->Write() ;
+   }
+  }
+ }
+ file->Close() ;
+ cout << " file " << output.Data() << " saved ... " << endl ;
+
+ timer.Stop() ;
+ cout << endl ;
+ timer.Print() ;
+ cout << " . here it was (efficiency2s) ... " << endl ;  //juice!
+ cout << endl ;
+
+ cout << endl ; cout << " Memory Check (from Paul)" << endl ; 
+ gObjectTable->Print();
+ cout << endl ; cout << endl ;
+
+ return 2 ;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Int_t eInit(const char* dir)
+{
+ TString fileName(dir) ; 
+ fileName += "AliESDs.root" ;
+ Long_t *id, *size, *flags, *modtime ;
+ if(gSystem->GetPathInfo(fileName.Data(),id,size,flags,modtime)) 
+ { 
+  cout << " File : " << fileName << " does NOT exist ! - Skipping ... " << endl ; 
+  return 0 ; 
+ }
+ esdChain = new TChain("esdTree") ;
+ esdChain->Add(fileName.Data()) ;
+ Int_t nEvents = esdChain->GetEntries() ;
+
+ return nEvents ;
+} 
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Int_t kInit(const char* dir)
+{
+ TString fileName(dir) ; 
+ fileName += "galice.root" ;
+ Long_t *id, *size, *flags, *modtime ;
+ if(gSystem->GetPathInfo(fileName.Data(),id,size,flags,modtime)) 
+ { 
+  cout << " File : " << fileName << " does NOT exist ! - Skipping ... " << endl ; 
+  return 0 ; 
+ }
+ rl = AliRunLoader::Open(fileName.Data(),"MyEvent","read");  // AliRunLoader* 
+ rl->LoadgAlice();
+ gAlice = rl->GetAliRun();  // AliRun*
+ rl->LoadHeader();
+ rl->LoadKinematics();
+ Int_t nEvents = rl->GetNumberOfEvents() ;
+ return nEvents ;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+TTree* kOpen(int evtN)
+{
+ Int_t exitStatus = rl->GetEvent(evtN) ; if(exitStatus!=0) { return 0 ; }
+
+ TTree* kTree = (TTree*)rl->TreeK();  // Particles TTree (KineTree)
+ kStack = gAlice->Stack();           // Particles Stack (use "Label()" to get the number in the stack)
+
+ Int_t fNumberOfParticles = kTree->GetEntries() ;
+ Int_t nPart = kStack->GetNtrack() ;
+ Int_t nPrim = kStack->GetNprimary() ;
+ if(fNumberOfParticles !=  nPart) { cout << " Something is wrong !!! " << fNumberOfParticles << " !=  " << nPart << " . " << endl ; }
+ // else { cout << " Event n. " << evtN << "  contains :  " << fNumberOfParticles << "  particles in the TTree  ( =  " << nPart << "  in the stack, " << nPrim << " ) . " << endl ; }
+
+ return kTree ; 
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//-----------------------------------------------------------------------
+//*** USEFULL METHODS for a 3-array of double (~ TVector3) ***
+//-----------------------------------------------------------------------
+Double_t Norm(Double_t nu[3])
+{ 
+ // returns the norm of a double[3] 
+
+ Double_t norm2 = nu[0]*nu[0] + nu[1]*nu[1] + nu[2]*nu[2] ;
+ return TMath::Sqrt(norm2) ; 
+}
+//-----------------------------------------------------------------------
+Double_t Phi(Double_t nu[3])
+{
+ // returns the azimuthal angle of a double[3] 
+
+ if(nu[0]==0 && nu[1]==0) { return 0. ; }
+ else                    { return TMath::ATan2(nu[1],nu[0]) ; }
+}
+//-----------------------------------------------------------------------
+Double_t Pt(Double_t nu[3])
+{
+ // returns the transvers momentum of a double[3] 
+
+ Double_t trans = nu[0]*nu[0] + nu[1]*nu[1] ;
+ return TMath::Sqrt(trans) ; 
+}
+//-----------------------------------------------------------------------
+Double_t Eta(Double_t nu[3])
+{
+ // returns the PseudoRapidity of a double[3] 
+ // if transvers momentum = 0 --> returns +/- 1.000
+
+ Double_t m = Norm(nu) ;
+ if(nu[0]!=0 || nu[1]!=0) { return 0.5*TMath::Log((m+nu[2])/(m-nu[2])) ; }
+ else                    { return TMath::Sign((Double_t)1000.,nu[2]) ; }
+}
+//-----------------------------------------------------------------------
index aaa2b4dec6462830d6a631008b24bc1abc409f14..43b8e4a289fadea1b5de9e5738b3c4228c447590 100644 (file)
 #include "TMath.h"
 #include "TObjArray"
 #include "TStopwatch.h"
+#include "TKey.h"
+#include "TList.h"
 
 using namespace std; //required for resolving the 'cout' symbol
 
-void testAnal(TString output = "flowEvtsAnal.root")
+int testAnal(int cen = -1)
 {
- cout << " . Here the new flow analysis (2007) ... " << endl ;
+ cout << " . Here the new flow analysis (2007 rs) ... " << endl ;
  cout << endl ;
 
  bool kOne = kFALSE ;
+ int limit = -1 ;
+
+ if(limit>0)
+ {
+  cout << " . limited to " << limit << "events . " << endl ;
+  cout << endl ;
+ }
+ // histogram file (output) //
+
+ TString output = "flowEvtsAnal" ; 
+ if(cen >= 0) { output += cen ; }
+ output += ".root" ;
+ // flowEvents chain (imput) //
+
+ TString fFlowFileName = "flowEvts" ;
+ if(cen >= 0) { fFlowFileName += cen ; }
+ fFlowFileName += ".root" ;
+
+ // Wgt file (optional) //
+
+ TString wgtFileName = "flowPhiWgt" ;
+ if(cen >= 0) { wgtFileName += cen ; }
+ wgtFileName += ".root" ;
+
+ // start, load libs //
 
  TStopwatch timer;
  timer.Start();
 
- gSystem->Load("libPhysics.so");
- //gSystem->Load("libPWG2.so");
+ //gSystem->Load("libPhysics.so");
  gSystem->Load("libPWG2flow.so");
 
- // output file //
+ // open output file //
 
  TFile * fFlowfile = new TFile(output.Data(),"RECREATE") ;
  //fFlowfile->cd() ; 
 
- // selection object (cuts) //
+ // selection object (cuts) // 
 
  AliFlowSelection* select = new AliFlowSelection() ;
  
  // Event Cuts
- select->SetCentralityCut(-1) ;
+ select->SetCentralityCut(-1) ;  // cen
  select->SetRunIdCut(-1) ;
 
  // R.P. calculation cuts
  for(int j=0;j<AliFlowConstants::kHars;j++)
  {
-  select->SetEtaCut(0., 1.1, j, 1) ;
+  select->SetEtaCut(0., 0.9, j, 1) ;
   select->SetPtCut(0.1, 10. , j, 1);
  }
  select->SetConstrainCut(kTRUE) ;
  select->SetDcaGlobalCut(0.,0.1);
- //select->SetNhitsCut(3., 1) ;
+ //select->SetNhitsCut(0, 1) ;
  //select->SetPidCut("pi");
 
  // Tracks Correlation analysis cuts
- select->SetEtaPart(-1.1,1.1);
+ select->SetEtaPart(-0.9,0.9);
  select->SetPtPart(0.1,10.);
  select->SetConstrainablePart(kTRUE);
  select->SetDcaGlobalPart(0.,0.1);
@@ -77,8 +105,8 @@ void testAnal(TString output = "flowEvtsAnal.root")
 
  // V0 Correlation analysis cuts
  //select->SetV0DcaCross(0.,0.1) ;
- select->SetV0Mass(0.4875,0.5078) ;    // Mk0 = 0.49765
- select->SetV0SideBands(0.08) ;
+ select->SetV0Mass(0.48,0.52) ;            // Mk0 = 0.49765
+ select->SetV0SideBands(0.10) ;
  //select->SetV0P(0.,10.) ;
  select->SetV0Pt(0.1,10.) ;
  select->SetV0Eta(-2.1,2.1) ;
@@ -100,23 +128,20 @@ void testAnal(TString output = "flowEvtsAnal.root")
  // flow analyser //
 
  AliFlowAnalyser* flow = new AliFlowAnalyser(select) ;
- AliFlowEvent* flowEvt = new AliFlowEvent() ;
 
  // output file
  flow->SetHistFileName(output.Data()) ;
  cout << " . Writing Histograms on  : " << flow->GetHistFileName()   << "  . " << endl ;
 
- // Wgt file
- TString wgtFileName = "flowPhiWgt.root" ;
+ // Wgt s
  TFile* wgtFile = new TFile(wgtFileName.Data(),"READ");
  if(!wgtFile || wgtFile->IsZombie()) { cout << " . NO phi Weights . " << endl ;}
  else { flow->FillWgtArrays(wgtFile) ; cout << " . Weights from  : " << flow->GetWgtFileName() << "  . " << endl ; }
 
  // Analysis settings
- flow->SetFlowForV0() ;         // default kTRUE.
- flow->SetEtaSub() ;            // default kFALSE
+ flow->SetFlowForV0(kFALSE) ;   // default kTRUE.
+ flow->SetSub(1) ; //eta // flow->SetSub(0) ; //rnd // flow->SetSub(-1) ; //charged
  //flow->SetV1Ep1Ep2() ;        // default kFALSE.
- flow->SetShuffle(kFALSE) ;     // default kFALSE. shuffles track array
  //flow->SetRedoWgt();         // default kFALSE. recalculates phiWgt (even if phiWgt file is already there)
  flow->SetUsePhiWgt(kFALSE) ;   // default kTRUE if phiWgt file is there, kFALSE if not (& phiWgt file is created)
  flow->SetUseOnePhiWgt() ; // or // flow->SetUseFirstLastPhiWgt() ; // uses 1 or 3 wgt histograms (default is 1)
@@ -128,27 +153,38 @@ void testAnal(TString output = "flowEvtsAnal.root")
  // init (make histograms, start the analysis)
  cout << endl ;
  kOne = flow->Init() ;  if(kOne) { cout << "   ok! " << endl ;}
- // flowEvents chain (imput) //
-
- TString fFlowFileName = "flowEvts.root" ;
 
  // organizing event loop
  TFile* flowEventsFile = new TFile(fFlowFileName.Data(), "READ") ; // flowEventsFile->ls() ;
  Int_t nEvts = flowEventsFile->GetNkeys() ; 
  cout << " . Found  " << nEvts << " AliFlowEvents in file " << fFlowFileName.Data() << endl ;
  TList* flowEventsList = (TList*)flowEventsFile->GetListOfKeys() ; 
+ AliFlowEvent* flowEvt = new AliFlowEvent() ;
+ TIter next(flowEventsList); 
+ TKey* key ;
 
- // event loop
  cout << endl ;
- for(Int_t ie=0;ie<nEvts;ie++)
+
+ // Loop over the events
+ Int_t count = 0 ;
+ while( key=(TKey *)next() ) 
  {
-  TString evtName = flowEventsList->At(ie)->GetName() ;
-  flowEventsFile->GetObject(evtName.Data(),flowEvt) ;
+  // TString evtName = flowEventsList->At(ie)->GetName() ;
+  // flowEventsFile->GetObject(evtName.Data(),flowEvt) ;
   // cout << "dumping event " << ie << " : " << endl ; flowEvt->Dump() ; cout << endl ; 
+
+  flowEvt = (AliFlowEvent *)key->ReadObj();
+  if(!flowEvt) break;
+
+  // Process event .......
   Bool_t succ = flow->Analyze(flowEvt) ;  
   flow->PrintEventQuantities() ;
-  if(succ) { cout << ie << " done ... " << endl ; } 
+  if(succ) { cout << count << " done ... " << endl ; }  
+  
+  delete flowEvt ;
+
+  if(count == limit) { break ; }  
+  count++ ;
  }
 
  // p.Id
@@ -171,9 +207,12 @@ void testAnal(TString output = "flowEvtsAnal.root")
  timer.Stop();
  cout << endl ;
  cout << " . " ; timer.Print();
- cout << " . here it was (analyser) ... " << endl ;  //juice!
+ cout << " . here it was (analyser rs) ... " << endl ;  //juice!
  cout << endl ;
-
- // break ;
  
+ // cout << endl ; cout << " Memory Check (from Paul)" << endl ; 
+ // gObjectTable->Print();
+ // cout << endl ; cout << endl ;
+
+ return cen ;
 }
index 01c797e3134d128d2fd27f8a711ecfac5197a636..f090847d4b239cb038e375024facd1e9b181b35a 100644 (file)
@@ -7,6 +7,7 @@ void testFoF(const Char_t* dataDir=".", Int_t nRuns = 10, Int_t offset = 0)
 {
  // include path (to find the .h files when compiling)
  gSystem->AddIncludePath("-I$ALICE_ROOT/include") ;
+ gSystem->AddIncludePath("-I$ROOTSYS/include") ;
 
  // load needed libraries
  gSystem->Load("libESD");
@@ -17,27 +18,26 @@ void testFoF(const Char_t* dataDir=".", Int_t nRuns = 10, Int_t offset = 0)
  gSystem->Load("libPWG2flow.so");
 
  // Selector
-  char *loadSelector = gSystem->ExpandPathName("$ALICE_ROOT/PWG2/FLOW/AliSelectorFoF.cxx+") ;
-  //gInterpreter->AddIncludePath(inc) ;
+ char *loadSelector = gSystem->ExpandPathName("$ALICE_ROOT/PWG2/FLOW/AliSelectorFoF.cxx+") ;
 
  // create the TChain. CreateESDChain() is defined in CreateESDChain.C
 TChain* chain = CreateESDChain(dataDir, nRuns, offset);
+ TChain* chain = CreateESDChain(dataDir, nRuns, offset);
 
 cout << " * " << chain->GetEntries() << " * " << endl ;
+ cout << " * " << chain->GetEntries() << " * " << endl ;
 
  // enable debugging
 AliLog::SetClassDebugLevel("AliSelectorFoF", AliLog::kInfo);
+ AliLog::SetClassDebugLevel("AliSelectorFoF", AliLog::kInfo);
 
  // run selector on chain
 Long64_t result = chain->Process(loadSelector);
+ Long64_t result = chain->Process(loadSelector);
 
 if (result != 0)
 {
-    printf("ERROR: Executing process failed with %d.\n", result);
-    return;
 }
+ if (result != 0)
+ {
+   printf("ERROR: Executing process failed with %d.\n", result);
+   return;
+ }
 
 printf("Execution complete.\n");
+ printf("Execution complete.\n");
 }
 
 // Helper macros for creating chains
index 35b8133cf60a02a6416cddefd27ffe2dd270d8fc..5ed8f5cc64c037e10faf4ac04ad795230464382a 100644 (file)
 
 using namespace std; //required for resolving the 'cout' symbol
 
-TTree* kOpen(int evtN=0) ;
-//TChain* CreateKineChain(const char* aDataDir = "MCfiles.txt", Int_t aRuns = 10, Int_t offset = 0) ;
-//void LookupWrite(TChain* chain, const char* target) ;
+const char* aDataDir = "./" ; Int_t aRuns = -1 ; Int_t offset = 0 ;
 
-void testKiner(TString output = "flowKevts.root")
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+int testKiner(int cen = -1)
 {
- cout << " . Here the new flow kinemaker (2007b) ... " << endl ;
+ cout << " . Here the new flow kinemaker (2007 noRL) ... " << endl ;
  cout << endl ;
 
- bool kOne = kFALSE ;
+ int limit = -1 ;
+ if(limit>0)
+ {
+  cout << " . limited to " << limit << "events . " << endl ;
+  cout << endl ;
+ }
+ // flowEvents file (output) //
+
+ TString output = "flowKevts" ;
+ if(cen >= 0) { output += cen ; }
+ output += ".root" ;
+ // start, load libs //
 
  TStopwatch timer;
  timer.Start();
 
- gSystem->Load("AliFlow_All.so");
+ //gSystem->Load("libPhysics.so");
+ gSystem->Load("libPWG2flow.so");
 
- // output file //
+ // open output file //
 
  TFile * fFlowfile = new TFile(output.Data(),"RECREATE") ;
  //fFlowfile->cd() ; 
 
- // esd chain //
-
-// // TString fESDfileName = "AliESDs.root" ; TString fESDtree = "esdTree" ; 
-// TChain* pMCchain = CreateESDChain(".",10,0);
-// Int_t fNumberOfEvents = (Int_t)pMCchain->GetEntries() ;
-// cout << " tot. " << fNumberOfEvents << " events in the TChain ... " << endl ; cout << endl ;
-
-// TString fKineBranch = "TreeK" ;
-// TTree treeK = 0 ;
-// pMCchain->SetBranchAddress(fKineBranch.Data(),&treeK) ;
-
- Int_t fNumberOfEvents = 1 ;
- TTree* treeK = 0 ;
-
  // flow maker //
 
  AliFlowKineMaker * flowKiner = new  AliFlowKineMaker() ;
  // cuts, etc.
- flowKiner->SetAbsEtaCut(2.1) ;
- flowKiner->SetECut(0.01,100.) ;
+ flowKiner->SetAbsEtaCut(10.) ;
+ flowKiner->SetECut(0.001,100.) ;
  //flowKiner->SetLabelCut(..,..) ;
- flowKiner->SetPrimaryCut(Bool_t prim = kTRUE) ;
+ flowKiner->SetPrimaryCut(kTRUE) ;
  flowKiner->PrintCutList() ;
 
- // loop //
-
- Int_t evtN = 0 ;
  AliFlowEvent * flowEvt = 0 ;
- for(evtN=0;evtN<fNumberOfEvents;evtN++)
+ Int_t count = 0 ;
+
+ // loop (folders) //
+
+ TString execDir(gSystem->pwd());
+ TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
+ TList* dirList           = baseDir->GetListOfFiles();
+ Int_t nDirs              = dirList->GetEntries();
+ gSystem->cd(execDir);
+ for(Int_t iDir=0; iDir<nDirs; ++iDir)
  {
-  treeK = kOpen(0) ;
-  
-  Int_t evtNN = -1 ;
-  Int_t nTrk = treeK->GetEntries() ;
+  TSystemFile* presentDir = (TSystemFile*)dirList->At(iDir) ;
+  if(!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0) 
+  {
+   cout << endl ; 
+   cout << "Directory (" << iDir << "):  " << presentDir->GetName() << " - Skipping ... " << endl ;
+   continue ;   
+  }
+  if(offset > 0)  { --offset ; continue ; }
+  if((aRuns > 0) && (count >= aRuns)) { break ; }
+  TString presentDirName(aDataDir);
+  presentDirName += presentDir->GetName();
+  presentDirName += "/";
+
+  TString fileName = presentDirName ; 
+  fileName += "galice.root" ;
+  Long_t *id, *size, *flags, *modtime ;
+  if(gSystem->GetPathInfo(fileName.Data(),id,size,flags,modtime)) 
+  { 
+   cout << " File : " << fileName << " does NOT exist ! - Skipping ... " << endl ; 
+   continue ; 
+  }
+  cout << endl ; cout << "Directory (" << iDir << "):  " << presentDirName << "  ... " << endl ;
+
+ // loop (simulations in the present dir) //
 
-  cout << endl ; cout << " Event " << evtN << "  ( " << evtNN << " )  : " << nTrk << " tracks  ." << endl ;
+  TSystemDirectory* evtsDir = new TSystemDirectory(".", presentDirName.Data());
+  TList* fileList          = evtsDir->GetListOfFiles();
+  Int_t nFiles             = fileList->GetEntries();
+  gSystem->cd(execDir);
 
-  flowEvt = flowKiner->FillFlowEvent(treeK) ;
+  for(Int_t iFiles=0; iFiles<nFiles; ++iFiles)
+  {
+   TSystemFile* presentFile = (TSystemFile*) fileList->At(iFiles);
 
-  cout << " Event filled " << flowEvt << " ... " << endl ;
-  // cout << endl ; cout << " trks : " << flowEvt->TrackCollection()->GetEntries() << endl ;
-  // flowEvt->Dump() ; cout << endl ;
+   TString presentFileName(presentDirName);
+   presentFileName += presentFile->GetName();
 
-  TString evtID = "" ; evtID += evtN ; 
-  fFlowfile->cd() ; 
-  flowEvt->Write(evtID.Data()) ;
-  cout <<  " Event " << evtN << "  ( " << evtID.Data() << " )  -  written on disk (" << output << ") ." << endl;
-  delete flowEvt ;
+   if(!(presentFileName.Contains("Kinematics") && presentFileName.Contains("root"))) { continue ; }
+
+   cout << " found: " << presentFileName.Data() << endl ; 
+  
+   TFile* kineFile = new TFile(presentFileName.Data(), "READ") ; 
+   // kineFile->ls() ;
+   Int_t nEvts = kineFile->GetNkeys() ; 
+   cout << "  . found: " << nEvts << " KineTree(s) in " << presentFileName.Data() << endl ;
+   TList* kineEventsList = (TList*)kineFile->GetListOfKeys() ; 
+   TTree* kTree ;
+   TIter next(kineEventsList); 
+   TKey* key ;
+
+   // Loop over the events
+   while( key=(TKey *)next() ) 
+   {
+    TDirectory* tDir = (TDirectory*)key->ReadObj() ;
+    if(!tDir) break;
+    TString evtDir(tDir->GetName()) ; 
+    cout << "  . . found: " << tDir->GetName() << endl ;
+
+    kTree = (TTree *)tDir->Get("TreeK");
+    if(!kTree) break;
+
+    Int_t nPart = kTree->GetEntries() ;
+    cout << "  . . . kTree " << count << " has " << nPart << " particles " << endl ;
+    
+   // fill and save the flow event
+    flowEvt = flowKiner->FillFlowEvent(kTree) ;
+    cout << "  . . . flowEvent " << flowEvt << " filled from ttree " << kTree << " ... " << endl ; 
+    // flowEvt->Dump() ; cout << endl ;
+    TString evtID = "" ; evtID += iDir ; evtID += "-" ; evtID += evtDir ; 
+    fFlowfile->cd() ; flowEvt->Write(evtID.Data()) ;
+    cout <<  "  . . . flowEvent " << flowEvt << "  ( " << evtID.Data() << " )  -  written on disk (" << output << ") ... " << endl;
+    delete flowEvt ; cout << endl ;
+   // -
+
+    if(count == limit) { break ; }
+    count ++ ;
+    
+    delete kTree ;
+   }
+   delete kineFile ;
+  }
+  delete evtsDir ;
  }
  
  fFlowfile->Close() ; 
  
  cout <<  endl ;
  cout << " Finished ... " << endl ;
- cout << "  nTracks:  " << flowKiner->GetNgoodTracks() << endl ;   
- cout << "  nV0s:  " << flowKiner->GetNgoodV0s()  << endl ;         
- cout << "  nTracks (|eta|<0.5):  " << flowKiner->GetNgoodTracksEta() << endl ; 
- cout << "  nTracks+:  " << flowKiner->GetNposiTracks() << endl ;           
- cout << "  nTracks-:  " << flowKiner->GetNnegaTracks() << endl ;           
- cout << "  nTracks unconstrained:  " << flowKiner->GetNunconstrained() << endl ;       
- //cout << "  Bayesian :  " ; 
- //for(int ii=0;ii<5;ii++) { cout << flowKiner->GetBayesianNorm(ii) << "   " ; } 
+ cout << "  nParticles:  " << (flowKiner->GetNgoodTracks() + flowKiner->GetNgoodV0s()) << " (" << flowKiner->GetNposiTracks() << "+ , " << flowKiner->GetNnegaTracks() << "- , " << flowKiner->GetNgoodV0s() << " neutral) " << endl ;   
+ cout << "  <nCharged> (|eta|<0.5):  " << (Int_t)(flowKiner->GetNgoodTracksEta()/count) << endl ; 
+ cout << "  Bayesian :  " ; 
+ for(int ii=0;ii<5;ii++) { cout << flowKiner->GetBayesianNorm(ii) << "   " ; } 
  cout << " . " << endl ; 
 
  timer.Stop() ;
  cout << endl ;
  timer.Print() ;
- cout << " . here it was (kiner) ... " << endl ;  //juice!
+ cout << " . here it was (kiner noRL) ... " << endl ;  //juice!
  cout << endl ;
 
- // break ;
-
-}
-
-TTree* kOpen(int evtN)
-{
- TString fileName = "./0/galice.root" ;
- AliRunLoader* rl = AliRunLoader::Open(fileName.Data(),"MyEvent","read");
- rl->LoadgAlice();
- AliRun* gAlice = rl->GetAliRun();
- rl->LoadHeader();
- rl->LoadKinematics();
- Int_t fNumberOfEvents = rl->GetNumberOfEvents() ;
- cout << " Found :  " << fNumberOfEvents << "  event(s) ... " << endl ; 
-
- Int_t exitStatus = rl->GetEvent(evtN) ; if(exitStatus!=0) { return 0 ; }
-
- TTree* kTree = (TTree*)rl->TreeK();         // Particles TTree (KineTree)
- AliStack* kStack = gAlice->Stack();         // Particles Stack (use "Label()" to get the number in the stack)
-
- Int_t fNumberOfParticles = kTree->GetEntries() ;
- Int_t nPart = kStack->GetNtrack() ;
- cout << " Event n. " << evtN << "  contains :  " << fNumberOfParticles << "  particles in the TTree  ( =  " << nPart << "  in the stack ) . " << endl ; 
+ // cout << endl ; cout << " Memory Check (from Paul)" << endl ; 
+ // gObjectTable->Print();
+ // cout << endl ; cout << endl ;
 
- return kTree ; 
+ return cen ;
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////
 
-// // Helper macros for creating chains (from: CreateESDChain.C,v 1.10 jgrosseo Exp)
-// TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
-// {
-//   // creates chain of files in a given directory or file containing a list.
-//   // In case of directory the structure is expected as:
-//   // <aDataDir>/<dir0>/AliESDs.root
-//   // <aDataDir>/<dir1>/AliESDs.root
-//   // ...
-// 
-//   if (!aDataDir)
-//     return 0;
-// 
-//   Long_t id, size, flags, modtime;
-//   if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
-//   {
-//     printf("%s not found.\n", aDataDir);
-//     return 0;
-//   }
-// 
-//   TChain* chain = new TChain("esdTree");
-//   TChain* chaingAlice = 0;
-// 
-//   if (flags & 2)
-//   {
-//     TString execDir(gSystem->pwd());
-//     TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
-//     TList* dirList            = baseDir->GetListOfFiles();
-//     Int_t nDirs               = dirList->GetEntries();
-//     gSystem->cd(execDir);
-// 
-//     Int_t count = 0;
-// 
-//     for (Int_t iDir=0; iDir<nDirs; ++iDir)
-//     {
-//       TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
-//       if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
-//         continue;
-// 
-//       if (offset > 0)
-//       {
-//         --offset;
-//         continue;
-//       }
-// 
-//       if (count++ == aRuns)
-//         break;
-// 
-//       TString presentDirName(aDataDir);
-//       presentDirName += "/";
-//       presentDirName += presentDir->GetName();
-// 
-//       chain->Add(presentDirName + "/AliESDs.root/esdTree");
-//     }
-//   }
-//   else
-//   {
-//     // Open the input stream
-//     ifstream in;
-//     in.open(aDataDir);
-// 
-//     Int_t count = 0;
-// 
-//     // Read the input list of files and add them to the chain
-//     TString esdfile;
-//     while(in.good()) {
-//       in >> esdfile;
-//       if (!esdfile.Contains("root")) continue; // protection
-// 
-//       if (offset > 0)
-//       {
-//         --offset;
-//         continue;
-//       }
-// 
-//       if (count++ == aRuns)
-//         break;
-// 
-//         // add esd file
-//       chain->Add(esdfile);
-//     }
-// 
-//     in.close();
-//   }
-// 
-//   return chain;
-// }
-// 
-// void LookupWrite(TChain* chain, const char* target)
-// {
-//   // looks up the chain and writes the remaining files to the text file target
-// 
-//   chain->Lookup();
-// 
-//   TObjArray* list = chain->GetListOfFiles();
-//   TIterator* iter = list->MakeIterator();
-//   TObject* obj = 0;
-// 
-//   ofstream outfile;
-//   outfile.open(target);
-// 
-//   while ((obj = iter->Next()))
-//     outfile << obj->GetTitle() << "#AliESDs.root" << endl;
-// 
-//   outfile.close();
-// 
-//   delete iter;
-// }
index b53616232093946d5d5fbe7af3fceb68520a845d..15e57fd181b2746a817aa503bc4bb84940603ffa 100644 (file)
 
 using namespace std; //required for resolving the 'cout' symbol
 
-TChain* CreateESDChain(const char* aDataDir = "ESDfiles.txt", Int_t aRuns = 10, Int_t offset = 0) ;
+TChain* CreateESDChain(const char* aDataDir = "ESDfiles.txt", Int_t aRuns = -1, Int_t offset = 0) ;
 void LookupWrite(TChain* chain, const char* target) ;
 
-void testMaker(TString output = "flowEvts.root")
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+int testMaker(int cen = -1)
 {
- cout << " . Here the new flow maker (2007b) ... " << endl ;
+ cout << " . Here the new flow maker (2007 rs) ... " << endl ;
  cout << endl ;
 
  bool kOne = kFALSE ;
+ int limit = -1 ;
+
+ if(limit>0)
+ {
+  cout << " . limited to " << limit << "events . " << endl ;
+  cout << endl ;
+ }
+ // flowEvents file (output) //
+
+ TString output = "flowEvts" ;
+ if(cen >= 0) { output += cen ; }
+ output += ".root" ;
+ // start, load libs //
 
  TStopwatch timer;
  timer.Start();
 
+ //gSystem->Load("libPhysics.so");
  gSystem->Load("libPWG2flow.so");
 
- // output file //
+ // open output file //
 
  TFile * fFlowfile = new TFile(output.Data(),"RECREATE") ;
  //fFlowfile->cd() ; 
 
- // esd chain //
+ // esd chain (imput) //
 
// TString fESDfileName = "AliESDs.root" ; TString fESDtree = "esdTree" ; 
- TChain* pESDchain = CreateESDChain(".",10,0);
TString baseDir = "." ; 
+ TChain* pESDchain = CreateESDChain(baseDir.Data(),limit,0);
  Int_t fNumberOfEvents = (Int_t)pESDchain->GetEntries() ;
  cout << " tot. " << fNumberOfEvents << " events in the TChain ... " << endl ; cout << endl ;
 
@@ -54,6 +72,11 @@ void testMaker(TString output = "flowEvts.root")
  // flow maker //
 
  AliFlowMaker * flowMaker = new  AliFlowMaker() ;
+
+ // flags 
+ flowMaker->DoTracks(kTRUE) ;
+ flowMaker->DoV0s(kFALSE) ;     // kTRUE
+
  // cuts, etc.
  flowMaker->SetNHitsCut(1) ;
  flowMaker->SetECut(0.01,100.) ;
@@ -63,39 +86,38 @@ void testMaker(TString output = "flowEvts.root")
  // loop //
 
  Int_t evtN = 0 ;
+ Int_t count = 0 ;
  AliFlowEvent * flowEvt = 0 ;
  for(evtN=0;evtN<fNumberOfEvents;evtN++)
  {
   pESDchain->GetEntry(evtN,1) ;
 
   Int_t evtNN = -1 ;
-  //  Int_t evtNN = pEsd->GetEventNumber() ;
+  // Int_t evtNN = pEsd->GetEventNumber() ;
   Int_t nTrk = pEsd->GetNumberOfTracks() ;
   Int_t nV0s = pEsd->GetNumberOfV0s() ;
   cout << endl ; cout << " Event " << evtN << "  ( " << evtNN << " )  : " << nTrk << " tracks  &  " << nV0s << " v0s ." << endl ;
 
   flowEvt = flowMaker->FillFlowEvent(pEsd) ;
-  cout << " Event filled " << flowEvt << " ... " << endl ;
-  // cout << endl ; cout << " trks : " << flowEvt->TrackCollection()->GetEntries() << endl ;
-  // flowEvt->Dump() ; cout << endl ;
+  // cout << " Event filled " << flowEvt << " ... " << endl ; // flowEvt->Dump() ; cout << endl ;
 
   TString evtID = "" ; evtID += evtN ; 
-  fFlowfile->cd() ; 
-  flowEvt->Write(evtID.Data()) ;
+  fFlowfile->cd() ; flowEvt->Write(evtID.Data()) ;
   cout <<  " Event " << evtN << "  ( " << evtID.Data() << " )  -  written on disk (" << output << ") ." << endl;
   delete flowEvt ;
+
+  if(count == limit) { break ; }  
+  count++ ;  
  }
  
  fFlowfile->Close() ; 
  
  cout <<  endl ;
  cout << " Finished ... " << endl ;
- cout << "  nTracks:  " << flowMaker->GetNgoodTracks() << endl ;   
- cout << "  nV0s:  " << flowMaker->GetNgoodV0s()  << endl ;         
+ cout << "  nTracks:  " << flowMaker->GetNgoodTracks() << " (" << flowMaker->GetNposiTracks() << "+ , " << flowMaker->GetNnegaTracks() << "-) " << endl ;   
+ cout << "  nV0s:  " << flowMaker->GetNgoodV0s() << endl ;          
  cout << "  nTracks (|eta|<0.5):  " << flowMaker->GetNgoodTracksEta() << endl ; 
- cout << "  nTracks+:  " << flowMaker->GetNposiTracks() << endl ;           
- cout << "  nTracks-:  " << flowMaker->GetNnegaTracks() << endl ;           
- cout << "  nTracks unconstrained:  " << flowMaker->GetNunconstrained() << endl ;       
+ // cout << "  nTracks unconstrained:  " << flowMaker->GetNunconstrained() << endl ;    
  cout << "  Bayesian :  " ; 
  for(int ii=0;ii<5;ii++) { cout << flowMaker->GetBayesianNorm(ii) << "   " ; } 
  cout << " . " << endl ; 
@@ -103,13 +125,17 @@ void testMaker(TString output = "flowEvts.root")
  timer.Stop() ;
  cout << endl ;
  timer.Print() ;
- cout << " . here it was (maker) ... " << endl ;  //juice!
+ cout << " . here it was (maker rs) ... " << endl ;  //juice!
  cout << endl ;
+ // cout << endl ; cout << " Memory Check (from Paul)" << endl ; 
+ // gObjectTable->Print();
+ // cout << endl ; cout << endl ;
 
- // break ;
-
+ return cen ;
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Helper macros for creating chains (from: CreateESDChain.C,v 1.10 jgrosseo Exp)
 TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
@@ -141,22 +167,34 @@ TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
     Int_t nDirs               = dirList->GetEntries();
     gSystem->cd(execDir);
 
+    cout << "* Reading :  " << aDataDir << "   (+" << nDirs << ")" << endl ;
+      
     Int_t count = 0;
 
     for (Int_t iDir=0; iDir<nDirs; ++iDir)
     {
       TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
       if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
+      {
+        cout << " Skip : " << presentDir->GetName() << endl ;
+      
         continue;
+      }
 
       if (offset > 0)
       {
+        cout << " OffSet : " << offset << endl ;
+      
         --offset;
         continue;
       }
 
       if (count++ == aRuns)
+      {
+        cout << " aRuns : " << aRuns << endl ;
+       
         break;
+      }
 
       TString presentDirName(aDataDir);
       presentDirName += "/";
@@ -198,6 +236,8 @@ TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
   return chain;
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void LookupWrite(TChain* chain, const char* target)
 {
   // looks up the chain and writes the remaining files to the text file target
@@ -218,3 +258,5 @@ void LookupWrite(TChain* chain, const char* target)
 
   delete iter;
 }
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
index 9fe1ae84a3d0c61bc846a8bf493c53c5c414df54..403a34e12dd039d40447c456b5aa8bd8d3d33501 100644 (file)
@@ -1,16 +1,17 @@
 #ifdef __CINT__
 
-#pragma link off all glols;
+#pragma link off all globals;
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ namespace AliFlowConstants;
+
 #pragma link C++ class AliFlowEvent+;
 #pragma link C++ class AliFlowTrack+;
 #pragma link C++ class AliFlowV0+;
 #pragma link C++ class AliFlowSelection+;
-#pragma link C++ class AliFlowConstants+;
-
 #pragma link C++ class AliFlowMaker+;
+#pragma link C++ class AliFlowKineMaker+;
 #pragma link C++ class AliFlowWeighter+;
 #pragma link C++ class AliFlowAnalyser+;
 
index b1b665dc98fc427c782beccb19614f4769c43af3..9042f5df97e3e73ffff926444896bd575684c13f 100644 (file)
@@ -5,6 +5,7 @@ SRCS= FLOW/AliFlowEvent.cxx \
       FLOW/AliFlowSelection.cxx \
       FLOW/AliFlowAnalyser.cxx \
       FLOW/AliFlowMaker.cxx \
+      FLOW/AliFlowKineMaker.cxx \
       FLOW/AliFlowWeighter.cxx 
 
 HDRS= $(SRCS:.cxx=.h)