Several changes:
authorfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Dec 2008 07:46:03 +0000 (07:46 +0000)
committerfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Dec 2008 07:46:03 +0000 (07:46 +0000)
- Removal of HBTAN
- Removal of libAnalysisOld (related to the above)
- Removal of the old event display (some remnants still need to be removed)
- Removal of the fHistogram data member in AliDetector, and related code
  (it was never used)
- Removal of Euclid files and related code
- Removal of the class depending on the above
- Simplification of AliRun (more to come!)

254 files changed:
ACORDE/AliACORDEv0.cxx
ACORDE/AliACORDEv0.h
ANALYSIS/AliAOD.cxx [deleted file]
ANALYSIS/AliAOD.h [deleted file]
ANALYSIS/AliAODPair.cxx [deleted file]
ANALYSIS/AliAODPair.h [deleted file]
ANALYSIS/AliAODPairBaseCut.cxx [deleted file]
ANALYSIS/AliAODPairBaseCut.h [deleted file]
ANALYSIS/AliAODPairCut.cxx [deleted file]
ANALYSIS/AliAODPairCut.h [deleted file]
ANALYSIS/AliAODParticle.cxx [deleted file]
ANALYSIS/AliAODParticle.h [deleted file]
ANALYSIS/AliAODParticleBaseCut.cxx [deleted file]
ANALYSIS/AliAODParticleBaseCut.h [deleted file]
ANALYSIS/AliAODParticleCut.cxx [deleted file]
ANALYSIS/AliAODParticleCut.h [deleted file]
ANALYSIS/AliAODRun.cxx [deleted file]
ANALYSIS/AliAODRun.h [deleted file]
ANALYSIS/AliAnalysis.cxx [deleted file]
ANALYSIS/AliAnalysis.h [deleted file]
ANALYSIS/AliAnalysisEventCuts.cxx [deleted file]
ANALYSIS/AliAnalysisEventCuts.h [deleted file]
ANALYSIS/AliAnalysisTrackCuts.cxx [deleted file]
ANALYSIS/AliAnalysisTrackCuts.h [deleted file]
ANALYSIS/AliClusterMap.cxx [deleted file]
ANALYSIS/AliClusterMap.h [deleted file]
ANALYSIS/AliEventBaseCut.cxx [deleted file]
ANALYSIS/AliEventBaseCut.h [deleted file]
ANALYSIS/AliEventBuffer.cxx [deleted file]
ANALYSIS/AliEventBuffer.h [deleted file]
ANALYSIS/AliEventCut.cxx [deleted file]
ANALYSIS/AliEventCut.h [deleted file]
ANALYSIS/AliFlowAnalysis.cxx [deleted file]
ANALYSIS/AliFlowAnalysis.h [deleted file]
ANALYSIS/AliMuonAnalysis.cxx [deleted file]
ANALYSIS/AliMuonAnalysis.h [deleted file]
ANALYSIS/AliReader.cxx [deleted file]
ANALYSIS/AliReader.h [deleted file]
ANALYSIS/AliReaderAOD.cxx [deleted file]
ANALYSIS/AliReaderESD.cxx [deleted file]
ANALYSIS/AliReaderESD.h [deleted file]
ANALYSIS/AliReaderESDTree.cxx [deleted file]
ANALYSIS/AliReaderESDTree.h [deleted file]
ANALYSIS/AliReaderKineTree.cxx [deleted file]
ANALYSIS/AliRunAnalysis.cxx [deleted file]
ANALYSIS/AliRunAnalysis.h [deleted file]
ANALYSIS/AliTrackPoints.cxx [deleted file]
ANALYSIS/AliTrackPoints.h [deleted file]
ANALYSIS/AliVAODParticle.cxx [deleted file]
ANALYSIS/AliVAODParticle.h [deleted file]
ANALYSIS/AnalysisOldLinkDef.h [deleted file]
ANALYSIS/CMakeLists.txt
ANALYSIS/CMake_libAnalysisOld.txt [deleted file]
ANALYSIS/TGliteXmlEventlist.cxx [deleted file]
ANALYSIS/libAnalysisOld.pkg [deleted file]
CMakeLists.txt
EMCAL/AliEMCALv0.cxx
EMCAL/AliEMCALv0.h
EMCAL/AliEMCALv2.cxx
EMCAL/AliEMCALv3.cxx
Euclid/ITSgeometry_5.det [deleted file]
Euclid/ITSgeometry_5.euc [deleted file]
Euclid/ITSgeometry_5.tme [deleted file]
Euclid/ITSgeometry_5asymm.det [deleted file]
Euclid/ITSgeometry_5asymm.euc [deleted file]
Euclid/ITSgeometry_5asymm.tme [deleted file]
Euclid/ITSgeometry_5symm.det [deleted file]
Euclid/ITSgeometry_5symm.euc [deleted file]
Euclid/ITSgeometry_5symm.tme [deleted file]
Euclid/bpipeb.euc [deleted file]
Euclid/bpumpa.euc [deleted file]
Euclid/frame.tme [deleted file]
Euclid/frame1099h.euc [deleted file]
Euclid/frame1099i.euc [deleted file]
Euclid/pipe.tme [deleted file]
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDDisplay.cxx
FMD/AliFMDDisplay.h
FMD/AliFMDPoints.cxx [deleted file]
FMD/AliFMDPoints.h [deleted file]
FMD/CMake_libFMDsim.txt
FMD/libFMDsim.pkg
HBTAN/.rootrc [deleted file]
HBTAN/AliHBTAnalysis.cxx [deleted file]
HBTAN/AliHBTAnalysis.h [deleted file]
HBTAN/AliHBTAnalysisStavinskyMixing.cxx [deleted file]
HBTAN/AliHBTAnalysisStavinskyMixing.h [deleted file]
HBTAN/AliHBTCorrFitFctn.cxx [deleted file]
HBTAN/AliHBTCorrFitFctn.h [deleted file]
HBTAN/AliHBTCorrectOSLCorrelFctn.cxx [deleted file]
HBTAN/AliHBTCorrectOSLCorrelFctn.h [deleted file]
HBTAN/AliHBTCorrectQInvCorrelFctn.cxx [deleted file]
HBTAN/AliHBTCorrectQInvCorrelFctn.h [deleted file]
HBTAN/AliHBTCorrelFctn.cxx [deleted file]
HBTAN/AliHBTCorrelFctn.h [deleted file]
HBTAN/AliHBTCrab.cxx [deleted file]
HBTAN/AliHBTCrab.h [deleted file]
HBTAN/AliHBTFunction.cxx [deleted file]
HBTAN/AliHBTFunction.h [deleted file]
HBTAN/AliHBTLLWeights.cxx [deleted file]
HBTAN/AliHBTLLWeights.h [deleted file]
HBTAN/AliHBTMonDistributionFctns.cxx [deleted file]
HBTAN/AliHBTMonDistributionFctns.h [deleted file]
HBTAN/AliHBTMonResolutionFctns.cxx [deleted file]
HBTAN/AliHBTMonResolutionFctns.h [deleted file]
HBTAN/AliHBTMonSplitting.cxx [deleted file]
HBTAN/AliHBTMonSplitting.h [deleted file]
HBTAN/AliHBTMonitorFunction.cxx [deleted file]
HBTAN/AliHBTMonitorFunction.h [deleted file]
HBTAN/AliHBTPIDPurityFctns.cxx [deleted file]
HBTAN/AliHBTPIDPurityFctns.h [deleted file]
HBTAN/AliHBTPair.cxx [deleted file]
HBTAN/AliHBTPair.h [deleted file]
HBTAN/AliHBTPositionRandomizer.cxx [deleted file]
HBTAN/AliHBTPositionRandomizer.h [deleted file]
HBTAN/AliHBTQDistributionVsKtFctns.cxx [deleted file]
HBTAN/AliHBTQDistributionVsKtFctns.h [deleted file]
HBTAN/AliHBTQDistributionVsQInvFctns.cxx [deleted file]
HBTAN/AliHBTQDistributionVsQInvFctns.h [deleted file]
HBTAN/AliHBTQResolutionFctns.cxx [deleted file]
HBTAN/AliHBTQResolutionFctns.h [deleted file]
HBTAN/AliHBTRDistributions.cxx [deleted file]
HBTAN/AliHBTRDistributions.h [deleted file]
HBTAN/AliHBTTwoTrackEffFctn.cxx [deleted file]
HBTAN/AliHBTTwoTrackEffFctn.h [deleted file]
HBTAN/AliHBTWeightFctn.cxx [deleted file]
HBTAN/AliHBTWeightFctn.h [deleted file]
HBTAN/AliHBTWeightTheorFctn.cxx [deleted file]
HBTAN/AliHBTWeightTheorFctn.h [deleted file]
HBTAN/AliHBTWeights.cxx [deleted file]
HBTAN/AliHBTWeights.h [deleted file]
HBTAN/AliHBTWeightsPID.cxx [deleted file]
HBTAN/AliHBTWeightsPID.h [deleted file]
HBTAN/AliHBTasCorrFctn.cxx [deleted file]
HBTAN/AliHBTasCorrFctn.h [deleted file]
HBTAN/AliHBTashbtCorrFctn.cxx [deleted file]
HBTAN/AliHBTashbtCorrFctn.h [deleted file]
HBTAN/CMakeLists.txt [deleted file]
HBTAN/CMake_libHBTAN.txt [deleted file]
HBTAN/HBTANLinkDef.h [deleted file]
HBTAN/WLedCOMMONS.h [deleted file]
HBTAN/fsiini.F [deleted file]
HBTAN/fsiw.F [deleted file]
HBTAN/hbtanalysis.C [deleted file]
HBTAN/hbtcorrections.C [deleted file]
HBTAN/led_bldata.F [deleted file]
HBTAN/libHBTAN.pkg [deleted file]
HBTAN/ltran12.F [deleted file]
HBTAN/volya_complex.h [deleted file]
HMPID/AliHMPID.h
ITS/AliITS.h
ITS/AliITSv11.cxx
ITS/AliITSv11.h
ITS/AliITSv11Hybrid.cxx
ITS/AliITSv11Hybrid.h
ITS/AliITSvPPRasymmFMD.cxx
ITS/AliITSvPPRasymmFMD.h
ITS/AliITSvPPRcoarseasymm.cxx
ITS/AliITSvPPRcoarseasymm.h
ITS/AliITSvSDD03.cxx
ITS/AliITSvSDD03.h
ITS/AliITSvSPD02.cxx
ITS/AliITSvSPD02.h
ITS/AliITSvSSD03.cxx
ITS/AliITSvSSD03.h
ITS/AliITSvtest.cxx [deleted file]
ITS/AliITSvtest.h [deleted file]
ITS/CMake_libITSsim.txt
ITS/ITSsimLinkDef.h
ITS/libITSsim.pkg
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/Doxymodules_STEER.h
Makefile
PHOS/AliPHOSv0.cxx
PHOS/AliPHOSv0.h
PHOS/AliPHOSvFast.cxx
PHOS/AliPHOSvFast.h
PMD/AliPMD.cxx
PMD/AliPMD.h
STEER/AliDetector.cxx
STEER/AliDetector.h
STEER/AliDisplay.cxx [deleted file]
STEER/AliDisplay.h [deleted file]
STEER/AliGenInfo.C
STEER/AliGenInfo.h
STEER/AliMC.cxx
STEER/AliMC.h
STEER/AliModule.cxx
STEER/AliModule.h
STEER/AliPoints.cxx [deleted file]
STEER/AliPoints.h [deleted file]
STEER/AliRun.cxx
STEER/AliRun.h
STEER/AliRunLoader.cxx
STEER/AliRunLoader.h
STEER/AliSimulation.cxx
STEER/AliSimulation.h
STEER/CMake_libSTEER.txt
STEER/CMake_libSTEER.txt.ori [deleted file]
STEER/STEERLinkDef.h
STEER/libSTEER.pkg
STRUCT/AliFRAMEv0.cxx [deleted file]
STRUCT/AliFRAMEv0.h [deleted file]
STRUCT/AliFRAMEv1.cxx [deleted file]
STRUCT/AliFRAMEv1.h [deleted file]
STRUCT/CMake_libSTRUCT.txt
STRUCT/STRUCTLinkDef.h
STRUCT/libSTRUCT.pkg
T0/AliT0.cxx
T0/AliT0.h
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFv0.cxx
TOF/AliTOFv0.h
TOF/AliTOFv1.cxx
TOF/AliTOFv1.h
TOF/AliTOFv2.cxx
TOF/AliTOFv2.h
TOF/AliTOFv2FHoles.cxx
TOF/AliTOFv2FHoles.h
TOF/AliTOFv3.cxx
TOF/AliTOFv3.h
TOF/AliTOFv4.cxx
TOF/AliTOFv4.h
TOF/AliTOFv4T0.cxx
TOF/AliTOFv4T0.h
TOF/AliTOFv5T0.cxx
TOF/AliTOFv5T0.h
TOF/AliTOFv6T0.cxx
TOF/AliTOFv6T0.h
TPC/AliTPC.cxx
TPC/AliTPC.h
TRD/AliTRD.cxx
TRD/AliTRD.h
TRD/Macros/AliTRDComparison.C
VZERO/AliVZERO.cxx
VZERO/AliVZERO.h
VZERO/AliVZEROv2.cxx
VZERO/AliVZEROv2.h
VZERO/AliVZEROv3.cxx
VZERO/AliVZEROv3.h
VZERO/AliVZEROv4.cxx
VZERO/AliVZEROv4.h
VZERO/AliVZEROv5.cxx
VZERO/AliVZEROv5.h
VZERO/AliVZEROv6.cxx
VZERO/AliVZEROv6.h
VZERO/AliVZEROv7.cxx
VZERO/AliVZEROv7.h
ZDC/AliZDC.cxx
ZDC/AliZDC.h
build/module.dep

index 2a0a07a..297b583 100644 (file)
@@ -77,13 +77,6 @@ AliACORDEv0::~AliACORDEv0()
   // Default destructor
   //
 }
-//_____________________________________________________________________________
-void AliACORDEv0::BuildGeometry()
-{
-
-  // not needed anymore
-
-}
 
 //_____________________________________________________________________________
 void AliACORDEv0::CreateGeometry()
index 99b31e9..08b77c4 100644 (file)
@@ -20,7 +20,6 @@ public:
   virtual Int_t IsVersion() const { return 1; }
   virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
 
-  virtual void BuildGeometry();
   virtual void CreateGeometry();
 
   virtual void Init();
diff --git a/ANALYSIS/AliAOD.cxx b/ANALYSIS/AliAOD.cxx
deleted file mode 100644 (file)
index 18a6a63..0000000
+++ /dev/null
@@ -1,432 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-/////////////////////////////////////////////////////////////
-//
-// base class for AOD containers
-//
-/////////////////////////////////////////////////////////////
-
-#include <TROOT.h>
-#include <TParticle.h>
-#include <TClass.h>
-#include <TString.h>
-
-#include "AliAOD.h"
-#include "AliAODParticle.h"
-#include "AliTrackPoints.h"
-
-ClassImp(AliAOD)
-
-AliAOD::AliAOD():
- fParticles(0x0),
- fIsRandomized(kFALSE),
- fPrimaryVertexX(0.0),
- fPrimaryVertexY(0.0),
- fPrimaryVertexZ(0.0),
- fParticleClass(0x0)
-{
- //ctor
-// Info("AliAOD()","Entered");
-// SetOwner(kTRUE);
-// Info("AliAOD()","Exited");
-}
-/**************************************************************************/
-
-AliAOD::AliAOD(const AliAOD& in):
- TObject(in),
- fParticles((TClonesArray*)in.fParticles->Clone()),
-  fIsRandomized(in.fIsRandomized),
-  fPrimaryVertexX(fPrimaryVertexX),
-  fPrimaryVertexY(in.fPrimaryVertexY),
-  fPrimaryVertexZ(in.fPrimaryVertexZ),
-  fParticleClass(in.fParticleClass)
-{
-//copy constructor
-}
-/**************************************************************************/
-
-AliAOD& AliAOD::operator=(const AliAOD& in)
-{
-//assigment operator  
-
-  if (this == &in ) return *this;
-  
-  delete fParticles;
-  fParticles = (TClonesArray*)in.fParticles->Clone();
-  fIsRandomized = in.fIsRandomized ;
-  fPrimaryVertexX = in.fPrimaryVertexX ;
-  fPrimaryVertexY = in.fPrimaryVertexY ;
-  fPrimaryVertexZ = in.fPrimaryVertexZ ;
-  fParticleClass = in.fParticleClass ; //althought it is pointer, this points to object in class list of gROOT
-  return *this;
-}
-/**************************************************************************/
-
-AliAOD::~AliAOD()
-{
-  //Destructor
-  //fParticleClass does not belong to AliAOD -> Do not delete it
-  delete fParticles;
-  
-}
-/**************************************************************************/
-
-void AliAOD::CopyData(AliAOD* aod)
-{
- //Copys all data from aod, but leaves local type of particles
- if (aod == 0x0) return;
- if (aod == this) return;
- AliAOD& in = *this;
- fIsRandomized = in.fIsRandomized ;
- fPrimaryVertexX = in.fPrimaryVertexX ;
- fPrimaryVertexY = in.fPrimaryVertexY ;
- fPrimaryVertexZ = in.fPrimaryVertexZ ;
- fParticleClass = in.fParticleClass ; //althought it is pointer, this points to object in class list of gROOT
-
- if (in.fParticles == 0x0)
-  {//if in obj has null fParticles we delete ours
-    delete fParticles;
-    fParticles = 0x0;
-  }
- else
-  { 
-    if (fParticles)
-     { //if ours particles were already created
-       if (fParticles->GetClass() != in.fParticles->GetClass())
-        {//if in obj has 
-          delete fParticles;
-          fParticles = (TClonesArray*)in.fParticles->Clone();
-        }
-       else
-        {
-         //it should be faster than cloning
-          Int_t inentr = in.fParticles->GetEntriesFast();
-          Int_t curentr = fParticles->GetEntriesFast();
-
-          TClonesArray& arr = *fParticles;
-
-          //we have to take care about different sizes of arrays
-          if ( curentr < inentr )
-           {
-             for (Int_t i = 0; i < curentr; i++)
-              {
-                TObject& inobj = *(in.fParticles->At(i));
-                TObject& obj = *(fParticles->At(i));
-                obj = inobj;
-              }
-             
-             TClass* partclass = GetParticleClass();
-             if (partclass == 0x0)
-              {
-                Fatal("CopyData","Can not get particle class");
-                return;//pro forma
-              }
-              
-             for (Int_t i = curentr; i < inentr; i++)
-              {
-                TObject& inobj = *(in.fParticles->At(i));
-                TObject& obj =  *((TObject*)(partclass->New(arr[i])));
-                obj = inobj;
-              }
-           }
-          else 
-           {
-             for (Int_t i = 0; i < inentr; i++)
-              {
-                TObject& inobj = *(in.fParticles->At(i));
-                TObject& obj = *(fParticles->At(i));
-                obj = inobj;
-              }
-             
-             for (Int_t i = curentr ; i >= inentr ; i--)
-              {
-                fParticles->RemoveAt(i);
-              }
-           }
-        } 
-     }
-    else
-     {
-       fParticles = (TClonesArray*)in.fParticles->Clone();
-     } 
-  } 
-}
-/**************************************************************************/
-
-void AliAOD::SetParticleClassName(const char* classname)
-{
-//Sets type of particle that is going to be stored 
-  if (gROOT == 0x0) Fatal("SetParticleClassName","ROOT System not initialized");
-  TClass* pclass = gROOT->GetClass(classname);
-  if ( pclass == 0x0 )
-   {
-     Error("SetParticleClass","Can not get TClass for class named %s",classname);
-     return;
-   }
-  SetParticleClass(pclass);
-}
-/**************************************************************************/
-
-void AliAOD::SetParticleClass(TClass* pclass)
-{
-//Sets type of particle that is going to be stored 
-
-  if ( pclass == 0x0 )
-   {
-     Error("SetParticleClass","Parameter is NULL.");
-     return;
-   }
-   
-  if ( pclass->InheritsFrom("AliVAODParticle") == kFALSE )
-   {
-     Error("SetParticleClass","Class named %s does not inherit from AliVAODParticle",pclass->GetName());
-     return;
-   }
-  if (pclass != fParticleClass)
-   {
-     fParticleClass = pclass;
-     if (fParticleClass) delete fParticles;
-     fParticles = new TClonesArray(fParticleClass);
-   }
-}
-/**************************************************************************/
-TClass* AliAOD::GetParticleClass()
-{
-//returns TClass of particle class
-  if (fParticleClass) return fParticleClass;
-  
-  if (fParticles == 0x0) return 0x0;
-  
-  fParticleClass = fParticles->GetClass();
-  return fParticleClass;
-}
-
-/**************************************************************************/
-
-void  AliAOD::AddParticle(TParticle* part, Int_t idx)
-{
-  //Adds TParticle to event
-  if (part == 0x0) 
-   {
-     Error("AddParticle(TParticle*,Int_t)","pointer to particle is NULL");
-     return;
-   }
-
-  if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
-  AddParticle( new AliAODParticle(*part,idx) );
-}
-/**************************************************************************/
-
-void  AliAOD::AddParticle(AliVAODParticle* particle)
-{
- //add particle to AOD
- //MAKES ITS OWN COPY OF THE PARTICLE!!! (AOD is not going to keep and delete input pointer)
-  if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
-
-  Int_t idx = fParticles->GetLast() + 1;
-  TClonesArray& arr = *fParticles;
-
-  TClass* partclass = GetParticleClass();
-  if (partclass == 0x0)
-   {
-     Error("AddParticle(AliVAODParticle*)","Can not get particle class");
-     return;
-   }
-  
-  AliVAODParticle* pp = (AliVAODParticle*)partclass->New(arr[idx]);
-  pp->operator=(*particle);
-  
-}
-/**************************************************************************/
-
-void  AliAOD::AddParticle(Int_t pdg, Int_t idx,
-                          Double_t px, Double_t py, Double_t pz, Double_t etot,
-                          Double_t vx, Double_t vy, Double_t vz, Double_t time)
-{
-  //adds particle to event (standard AOD class)
-
-  if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
-
-  Int_t newpartidx = fParticles->GetLast() + 1;
-  TClonesArray& arr = *fParticles;
-
-  TClass* partclass = GetParticleClass();
-  if (partclass == 0x0)
-   {
-     Error("AddParticle(Int_t,...)","Can not get particle class");
-     return;
-   }
-
-  AliVAODParticle* p =  (AliVAODParticle*)partclass->New(arr[newpartidx]);
-  
-  p->SetPdgCode(pdg);
-  p->SetUID(idx);
-  p->SetMomentum(px,py,pz,etot);
-  p->SetProductionVertex(vx,vy,vz,time);
-  
-}
-/**************************************************************************/
-
-void AliAOD::SwapParticles(Int_t i, Int_t j)
-{
-//swaps particles positions; used by AliHBTEvent::Blend
-  if ( (i<0) || (i>=GetNumberOfParticles()) ) return;
-  if ( (j<0) || (j>=GetNumberOfParticles()) ) return;
-  
-
-  TClass* partclass = GetParticleClass();
-  if (partclass == 0x0)
-   {
-     Error("SwapParticles","Can not get particle class");
-     return;
-   }
-    
-  AliVAODParticle* tmpobj = (AliVAODParticle*)partclass->New();
-  AliVAODParticle& tmp = *tmpobj;
-  AliVAODParticle& first = *(GetParticle(i));
-  AliVAODParticle& second = *(GetParticle(j));
-  
-  tmp = first;
-  first = second;
-  second = tmp;
-  delete tmpobj;
-}
-/**************************************************************************/
-
-void  AliAOD::Reset()
-{
-  //deletes all particles from the event
-   if (fParticles) fParticles->Clear("C");
-   
-   fIsRandomized = kFALSE;
-}
-/**************************************************************************/
-
-void AliAOD::GetPrimaryVertex(Double_t&x, Double_t&y, Double_t&z)
-{
-//returns positions of the primary vertex
-  x = fPrimaryVertexX;
-  y = fPrimaryVertexY;
-  z = fPrimaryVertexZ;
-}
-/**************************************************************************/
-
-void AliAOD::SetPrimaryVertex(Double_t x, Double_t y, Double_t z)
-{
-//Sets positions of the primary vertex 
-  fPrimaryVertexX = x;
-  fPrimaryVertexY = y;
-  fPrimaryVertexZ = z;
-}
-/**************************************************************************/
-
-Int_t AliAOD::GetNumberOfCharged(Double_t etamin, Double_t etamax) const
-{
-  //reurns number of charged particles within given pseudorapidity range
-  Int_t n = 0;
-  Int_t npart = GetNumberOfParticles();
-  for (Int_t i = 0; i < npart; i++)
-   {
-     AliVAODParticle* p = GetParticle(i);
-     Double_t eta = p->Eta();
-     if ( (eta < etamin) || (eta > etamax) ) continue;
-     if (p->Charge() != 0.0) n++;
-   }
-  return n;
-}
-/**************************************************************************/
-
-void AliAOD::Move(Double_t x, Double_t y, Double_t z)
-{
- //moves all spacial coordinates about this vector
- // vertex
- // track points
- // and whatever will be added to AOD and AOD particles that is a space coordinate
-
-  fPrimaryVertexX += x;
-  fPrimaryVertexY += y;
-  fPrimaryVertexZ += z;
-
-  Int_t npart = GetNumberOfParticles();
-  for (Int_t i = 0; i < npart; i++)
-   {
-     AliVAODParticle* p = GetParticle(i);
-     AliTrackPoints* tp  = p->GetTPCTrackPoints();
-     if (tp) tp->Move(x,y,z);
-     tp  = p->GetITSTrackPoints();
-     if (tp) tp->Move(x,y,z);
-   }
-}
-/**************************************************************************/
-
-void AliAOD::Print(const Option_t* /*option*/) const
-{
-  //Prints AOD
-  TString ts;
-  TString msg("\n");
-  msg+="Particle Class: ";
-  if (fParticleClass)
-   {
-     msg+=fParticleClass->GetName();
-   }
-  else
-   {
-     msg+="Not specified yet";
-   } 
-  msg += "\n";
-  msg += "Vertex position X: ";
-  msg += fPrimaryVertexX;
-  msg += " Y:" ;
-  msg += fPrimaryVertexY;
-  msg += " Z:";
-  msg += fPrimaryVertexZ;
-  msg += "\n";
-  
-  msg += "Randomized: ";
-  msg += fIsRandomized;
-  msg += "\n";
-  
-  Info("Print","%s",msg.Data());
-  
-  Int_t npart = GetNumberOfParticles();
-  Info("Print","Npart: %d",npart);
-  for (Int_t i = 0; i < npart; i++)
-   {
-     Info("Print","Getting particle %d",i);
-     AliVAODParticle* p = GetParticle(i);
-     Info("Print","Printing particle %d, address %#x",i,p);
-     p->Dump();
-     p->Print();
-     Info("Print","particle %d printed",i);
-   }
-}
-
-void AliAOD::SetOwner(Bool_t /*owner*/)
-{
-//Sets the ownership of particles: if particles should be also deleted if AOD is deleted/reseted
-//Since fParticles is Clones and not Object Array, it is always the owner and this method does not have sense
- MayNotUse("SetOwner");
- //if fParticles->SetOwner(owner);
-}
diff --git a/ANALYSIS/AliAOD.h b/ANALYSIS/AliAOD.h
deleted file mode 100644 (file)
index f5fc6cd..0000000
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef ALIAOD_H
-#define ALIAOD_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-/////////////////////////////////////////////////////////////
-//
-// base class for AOD containers
-//
-/////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include <TClonesArray.h>
-#include "AliVAODParticle.h"
-
-class TParticle;
-
-class AliAOD: public TObject {
-public:
-  AliAOD();
-  virtual ~AliAOD();
-  
-  AliAOD(const AliAOD& in);
-  virtual AliAOD& operator=(const AliAOD& in);
-  virtual void             CopyData(AliAOD* aod);//Copys all data from aod, but leaves local type of particles
-  
-  virtual TClonesArray*    GetParticles() const {return fParticles;} 
-  virtual void             SetParticleClassName(const char* classname);
-  virtual void             SetParticleClass(TClass* pclass);
-  
-  virtual Int_t            GetNumberOfParticles() const  {return (fParticles)?fParticles->GetEntriesFast():0;}
-  virtual AliVAODParticle* GetParticle(Int_t index) const {return  (fParticles)?(AliVAODParticle*)fParticles->At(index):0x0;}
-  virtual void             AddParticle(AliVAODParticle* particle);
-  virtual void             AddParticle(TParticle* part, Int_t idx); //adds particle to the event
-  virtual void             AddParticle(Int_t pdg, Int_t idx, Double_t px, Double_t py, Double_t pz, Double_t etot,
-                                       Double_t vx, Double_t vy, Double_t vz, Double_t time);
-  
-  virtual void             Reset();
-  
-  void                     SwapParticles(Int_t i, Int_t j);//swaps particles positions; used by AliReader::Blend
-  Bool_t                   IsRandomized() const {return fIsRandomized;}
-  void                     SetRandomized(Bool_t flag = kTRUE){fIsRandomized = flag;}
-  
-  void                     GetPrimaryVertex(Double_t&x, Double_t&y, Double_t&z);
-  void                     SetPrimaryVertex(Double_t x, Double_t y, Double_t z);
-  
-  Int_t                    GetNumberOfCharged(Double_t etamin = -10.0, Double_t etamax = 10.0) const;
-  void                     Move(Double_t x, Double_t y, Double_t z);//moves all spacial coordinates about this vector
-  virtual void             SetOwner(Bool_t owner);
-  virtual void             Print(const Option_t* /*option*/ = "") const;
-  TClass*                  GetParticleClass();
-private:
-  TClonesArray            *fParticles;   // array of AOD particles, AliAOD is owner of particles
-  Bool_t                   fIsRandomized;//flag indicating if positions of particles were randomized - used by HBTAN
-  Double_t                 fPrimaryVertexX;//X position of the primary vertex
-  Double_t                 fPrimaryVertexY;//Y position of the primary vertex
-  Double_t                 fPrimaryVertexZ;//Z position of the primary vertex
-  TClass*                  fParticleClass;//!object that defines type of the particle       
-  
-  ClassDef(AliAOD,1)  // base class for AOD containers
-};
-
-#endif
diff --git a/ANALYSIS/AliAODPair.cxx b/ANALYSIS/AliAODPair.cxx
deleted file mode 100644 (file)
index a6ed0fa..0000000
+++ /dev/null
@@ -1,657 +0,0 @@
-#include "AliAODPair.h"
-//_________________________________________________________________________
-///////////////////////////////////////////////////////////////////////////
-//
-// class AliAODPair
-//
-// class implements pair of particles and taking care of caluclation (almost)
-// all of pair properties (Qinv, InvMass,...)
-// 
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
-//
-////////////////////////////////////////////////////////////////////////////
-
-#include "AliVAODParticle.h"
-#include "AliTrackPoints.h"
-ClassImp(AliAODPair)
-
-/************************************************************************/
-AliAODPair::AliAODPair(Bool_t rev):
- fPart1(0x0),
- fPart2(0x0),
- fSwappedPair(0x0),
- fQSideLCMS(0.0),
- fQSideLCMSNotCalc(kTRUE),
- fQOutLCMS(0.0),
- fQOutLCMSNotCalc(kTRUE),
- fQLongLCMS(0.0),
- fQLongLCMSNotCalc(kTRUE),
- fQtLCMS(0.0),
- fQtLCMSNotCalc(kTRUE),
- fQt(0.0),
- fQtNotCalc(kTRUE),
- fQInv(0.0),
- fQInvNotCalc(kTRUE),
- fInvMass(0.0),
- fInvMassNotCalc(kTRUE),
- fKt(0.0),
- fKtNotCalc(kTRUE),
- fKStar(0.0),
- fKStarNotCalc(kTRUE),
- fKStarOut(0.0),
- fKStarSide(0.0),
- fKStarLong(0.0),
- fKStarCompNotCalc(kTRUE),
- fPInv(0.0),
- fQSide(0.0),
- fOut(0.0),
- fQLong(0.0),
- fMt(0.0),
- fMtNotCalc(kTRUE),
- fInvMassSqr(0.0),
- fMassSqrNotCalc(kTRUE),
- fQInvL(0.0),
- fQInvLNotCalc(kTRUE),
- fAvarageDistance(0.0),
- fAvarageDistanceNotCalc(kTRUE),
- fPxSum(0.0),
- fPySum(0.0),
- fPzSum(0.0),
- fESum(0.0),
- fSumsNotCalc(kTRUE),
- fPxDiff(0.0),
- fPyDiff(0.0),
- fPzDiff(0.0),
- fEDiff(0.0),
- fDiffsNotCalc(kTRUE),
- fGammaLCMS(0.0),
- fGammaLCMSNotCalc(kTRUE),
- fChanged(kTRUE)
- {
-//value of rev defines if it is Swapped
-//if you pass kTRUE swpaped pair will NOT be created
-//though you wont be able to get the swaped pair from this pair
-
-  if(!rev) fSwappedPair = new AliAODPair(kTRUE); //if false create swaped pair
-  
- }
-/************************************************************************/
-
-AliAODPair::AliAODPair(AliVAODParticle* part1, AliVAODParticle* part2, Bool_t rev):
- fPart1(part1),
- fPart2(part2),
- fSwappedPair(0x0),
- fQSideLCMS(0.0),
- fQSideLCMSNotCalc(kTRUE),
- fQOutLCMS(0.0),
- fQOutLCMSNotCalc(kTRUE),
- fQLongLCMS(0.0),
- fQLongLCMSNotCalc(kTRUE),
- fQtLCMS(0.0),
- fQtLCMSNotCalc(kTRUE),
- fQt(0.0),
- fQtNotCalc(kTRUE),
- fQInv(0.0),
- fQInvNotCalc(kTRUE),
- fInvMass(0.0),
- fInvMassNotCalc(kTRUE),
- fKt(0.0),
- fKtNotCalc(kTRUE),
- fKStar(0.0),
- fKStarNotCalc(kTRUE),
- fKStarOut(0.0),
- fKStarSide(0.0),
- fKStarLong(0.0),
- fKStarCompNotCalc(kTRUE),
- fPInv(0.0),
- fQSide(0.0),
- fOut(0.0),
- fQLong(0.0),
- fMt(0.0),
- fMtNotCalc(kTRUE),
- fInvMassSqr(0.0),
- fMassSqrNotCalc(kTRUE),
- fQInvL(0.0),
- fQInvLNotCalc(kTRUE),
- fAvarageDistance(0.0),
- fAvarageDistanceNotCalc(kTRUE),
- fPxSum(0.0),
- fPySum(0.0),
- fPzSum(0.0),
- fESum(0.0),
- fSumsNotCalc(kTRUE),
- fPxDiff(0.0),
- fPyDiff(0.0),
- fPzDiff(0.0),
- fEDiff(0.0),
- fDiffsNotCalc(kTRUE),
- fGammaLCMS(0.0),
- fGammaLCMSNotCalc(kTRUE),
- fChanged(kTRUE)
- {
-//value of rev defines if it is Swapped
-//if you pass kTRUE swpaped pair will NOT be created
-//though you wont be able to get the swaped pair from this pair
-
-  if(!rev) fSwappedPair = new AliAODPair(part2,part1,kTRUE); //if false create swaped pair
-  
- }
-/************************************************************************/
-AliAODPair::AliAODPair(const AliAODPair& in):
- TObject(in),
- fPart1(0x0),
- fPart2(0x0),
- fSwappedPair(0x0),
- fQSideLCMS(0.0),
- fQSideLCMSNotCalc(kTRUE),
- fQOutLCMS(0.0),
- fQOutLCMSNotCalc(kTRUE),
- fQLongLCMS(0.0),
- fQLongLCMSNotCalc(kTRUE),
- fQtLCMS(0.0),
- fQtLCMSNotCalc(kTRUE),
- fQt(0.0),
- fQtNotCalc(kTRUE),
- fQInv(0.0),
- fQInvNotCalc(kTRUE),
- fInvMass(0.0),
- fInvMassNotCalc(kTRUE),
- fKt(0.0),
- fKtNotCalc(kTRUE),
- fKStar(0.0),
- fKStarNotCalc(kTRUE),
- fKStarOut(0.0),
- fKStarSide(0.0),
- fKStarLong(0.0),
- fKStarCompNotCalc(kTRUE),
- fPInv(0.0),
- fQSide(0.0),
- fOut(0.0),
- fQLong(0.0),
- fMt(0.0),
- fMtNotCalc(kTRUE),
- fInvMassSqr(0.0),
- fMassSqrNotCalc(kTRUE),
- fQInvL(0.0),
- fQInvLNotCalc(kTRUE),
- fAvarageDistance(0.0),
- fAvarageDistanceNotCalc(kTRUE),
- fPxSum(0.0),
- fPySum(0.0),
- fPzSum(0.0),
- fESum(0.0),
- fSumsNotCalc(kTRUE),
- fPxDiff(0.0),
- fPyDiff(0.0),
- fPzDiff(0.0),
- fEDiff(0.0),
- fDiffsNotCalc(kTRUE),
- fGammaLCMS(0.0),
- fGammaLCMSNotCalc(kTRUE),
- fChanged(kTRUE)
-{
- //cpy constructor
- in.Copy(*this);
-}
-/************************************************************************/
-
-AliAODPair& AliAODPair::operator=(const AliAODPair& in)
-{
- //Assigment operator
- in.Copy(*this);
- return *this;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetInvMass()
-{
-//Returns qinv value for a pair
-  if(fInvMassNotCalc)
-   {
-     CalculateInvMassSqr(); //method is inline so we not waste th time for jumping into method 
-     
-     if(fInvMassSqr<0)  fInvMass = TMath::Sqrt(-fInvMassSqr);
-     else fInvMass = TMath::Sqrt(fInvMassSqr); 
-     
-     fInvMassNotCalc = kFALSE;
-   }
-  return fInvMass;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetQSideLCMS()
-{
-//return Q Side in Central Of Mass System in Longitudialy Comoving Frame
-  if (fQSideLCMSNotCalc)
-   {
-    fQSideLCMS = (fPart1->Px()*fPart2->Py()-fPart2->Px()*fPart1->Py())/GetKt();
-    fQSideLCMSNotCalc = kFALSE;
-   }
-  return fQSideLCMS;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetQOutLCMS()
-{
- //caculates Qout in Center Of Mass Longitudionally Co-Moving
- if(fQOutLCMSNotCalc)
-  {
-   CalculateSums();
-   CalculateDiffs();
-
-   if (fPart1->Mass() != fPart2->Mass())
-    {
-/*    
-      //STAR algorithm
-      Double_t beta  = fPzSum/fESum;
-      Double_t gamma = GetGammaToLCMS();
-      Double_t el = gamma * (fPart1->E() - beta * fPart1->Pz());
-      Double_t x  = ( fPart1->Px()*fPxSum + fPart1->Py()*fPySum) / ( 2.0*GetKt() );
-      beta  = 2.0*GetKt()/GetMt();
-      gamma = GetMt()/GetQInv();
-      fQOutLCMS = gamma * (x - beta * el);
-*/
-
-      //beta=fPzSum/fESum;    // Longit. V == beta
-      Double_t beta=fPzSum/fESum;
-      Double_t gamma = GetGammaToLCMS();
-      
-      Double_t cosphi=fPxSum/(2.0*GetKt());  // cos(phi)
-      Double_t sinphi=fPySum/(2.0*GetKt()); // sin(phi)
-      
-//      ROTATE(part1Px,part1Py,SPHI,CPHI,part1Px,part1Py);//ROT8
-//      ROTATE(part2Px,part2Py,SPHI,CPHI,part2Px,part2Py);//ROT8
-      Double_t tmp;
-      tmp = fPart1->Px()*cosphi + fPart1->Py()*sinphi;
-      Double_t part1Py = fPart1->Py()*cosphi - fPart1->Px()*sinphi;
-      Double_t part1Px = tmp;
-
-      tmp = fPart2->Px()*cosphi + fPart2->Py()*sinphi;
-      Double_t part2Py = fPart2->Py()*cosphi - fPart2->Px()*sinphi;
-      Double_t part2Px = tmp;
-      
-      
-//      LTR(part1Pz,E1,beta,GetGammaToLCMS(),part1Pz,E1a);
-//      LTR(part2Pz,E2,beta,GetGammaToLCMS(),part2Pz,E2a);
-      Double_t part1Pz=gamma*(fPart1->Pz()-beta*fPart1->E());
-      Double_t part2Pz=gamma*(fPart2->Pz()-beta*fPart2->E());
-
-      Double_t part1P2=part1Px*part1Px+part1Py*part1Py+part1Pz*part1Pz;
-      Double_t part2P2=part2Px*part2Px+part2Py*part2Py+part2Pz*part2Pz;
-      Double_t part1E=TMath::Sqrt(fPart1->Mass()*fPart1->Mass()+part1P2);
-      Double_t part2E=TMath::Sqrt(fPart2->Mass()*fPart2->Mass()+part2P2);
-      Double_t sumE=part1E+part2E;
-      Double_t sumPx=part1Px+part2Px;
-      Double_t sumPy=part1Py+part2Py;
-      Double_t sumPZ=part1Pz+part2Pz;
-      Double_t sumP2=sumPx*sumPx+sumPy*sumPy+sumPZ*sumPZ;
-
-      Double_t relmass=TMath::Sqrt(sumE*sumE-sumP2);
-      Double_t hf = (fPart1->Mass()*fPart1->Mass() - fPart2->Mass()*fPart2->Mass())/(relmass*relmass);
-      fQOutLCMS=(part1Px-part2Px);//== id
-      fQOutLCMS=fQOutLCMS-sumPx*hf; //sumPx == fPxSum ale po rotacji i transf
-    }
-   else
-    {
-      Double_t k2 = fPxSum*fPxDiff+fPySum*fPyDiff;
-      fQOutLCMS = 0.5*k2/GetKt();
-   // if (non-id)  fQOutLCMS=fQOutLCMS - sumPx*HF;
-    }
-
-    
-   fQOutLCMSNotCalc = kFALSE;
-  }
- return fQOutLCMS;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetQLongLCMS()
-{
- //return Q Long in Central Of Mass System in Longitudialy Comoving Frame
- if (fQLongLCMSNotCalc)
-  {
-    CalculateSums();
-    CalculateDiffs();
-    Double_t beta = fPzSum/fESum;
-    fQLongLCMS = GetGammaToLCMS() * ( fPzDiff - beta*fEDiff );
-    fQLongLCMSNotCalc = kFALSE;
-  }
- return fQLongLCMS; 
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetQtLCMS()
-{
- //returns Q transverse CMS longitudionally co-moving
- if (fQtLCMSNotCalc)
-  {
-    fQtLCMS = TMath::Hypot(GetQOutLCMS(),GetQSideLCMS());
-    fQtLCMSNotCalc = kFALSE;
-  }
- return fQtLCMS; 
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetQt()
-{
- //returns Q transverse CMS longitudionally co-moving
- if (fQtNotCalc)
-  {
-    CalculateSums();
-    CalculateDiffs();
-    
-    Double_t dotprod = fPxSum*fPxDiff + fPySum*fPyDiff + fPzSum*fPzDiff;
-    Double_t klen =    fPxSum*fPxSum  + fPySum*fPySum  + fPzSum*fPzSum;
-    klen = TMath::Sqrt(klen);
-    Double_t qlen =    fPxDiff*fPxDiff + fPyDiff*fPyDiff + fPzDiff*fPzDiff;
-    qlen = TMath::Sqrt(qlen);
-    Double_t tmp = klen*qlen;
-    if (tmp == 0.0)
-     {
-       fQt = 10e5;
-       fQtNotCalc = kFALSE;
-       return fQt;
-     }
-    Double_t cosopenangle = dotprod/tmp;
-    Double_t sinopenangle = TMath::Sqrt(1.0 - cosopenangle*cosopenangle);
-    
-    fQt = sinopenangle*qlen;
-    fQtNotCalc = kFALSE;
-  }
- return fQt; 
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetKt()
-{
- //calculates the evarage momentum of the pair
-  if(fKtNotCalc)
-   { 
-     CalculateSums();
-     fKt =  0.5*TMath::Hypot(fPxSum,fPySum);
-     fKtNotCalc = kFALSE;
-   }
-  return fKt;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetKStar()
-{
-  //calculates invariant velocity difference
-  if (fKStarNotCalc)
-   { 
-    CalculateSums();
-
-    Double_t ptrans = fPxSum*fPxSum + fPySum*fPySum;
-    Double_t mtrans = fESum*fESum - fPzSum*fPzSum;
-    if (ptrans > mtrans)
-     {
-       Error("GetKStar","Tranverse momentum bigger than transverse mass. Not normal for on-shell particles");
-       Error("GetKStar","Particle1:");
-       fPart1->Print();
-       Error("GetKStar","Particle2:");
-       fPart2->Print();
-       Error("GetKStar","");
-       
-       fKStar = 10e5;
-       fKStarNotCalc = kFALSE;
-       return fKStar;
-     }
-    Double_t pinv =   TMath::Sqrt(mtrans - ptrans);
-
-    Double_t q = (fPart1->Mass()*fPart1->Mass() - fPart2->Mass()*fPart2->Mass())/pinv;
-    
-    CalculateQInvL();
-    
-    q = q*q - fQInvL;
-    if ( q < 0)
-     {
-       Info("GetKStar","Sqrt of negative number q = %f",q);
-       Error("GetKStar","Particle1:");
-       fPart1->Print();
-       Error("GetKStar","Particle2:");
-       fPart2->Print();
-       fKStar = 10e5;
-       fKStarNotCalc = kFALSE;
-       return fKStar;
-     }
-     
-    q = TMath::Sqrt(q);
-    fKStar = q/2.;
-    fKStarNotCalc = kFALSE;
-   }
-  return fKStar;
-}
-/************************************************************************/
-Double_t AliAODPair::GetKStarOut()
-{
-    CalculateKStarComp();
-    return fKStarOut;
-}
-/************************************************************************/
-Double_t AliAODPair::GetKStarSide()
-{
-    CalculateKStarComp();
-    return fKStarSide;
-}
-/************************************************************************/
-Double_t AliAODPair::GetKStarLong()
-{
-    CalculateKStarComp();
-    return fKStarLong;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetQInv()
-{
-//returns Qinv 
-//warning for non-id particles you want to use 2*KStar
-  if(fQInvNotCalc)
-   {
-    CalculateQInvL();
-    fQInv = TMath::Sqrt(TMath::Abs(fQInvL));
-    fQInvNotCalc = kFALSE;
-   }
-  return fQInv;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetGammaToLCMS()
-{
-  //calculates gamma factor of the boost to LCMS
-  if(fGammaLCMSNotCalc)
-   {
-     CalculateSums();
-     Double_t beta = fPzSum/fESum;
-     fGammaLCMS = 1.0/TMath::Sqrt(1.0 - beta*beta);
-     fGammaLCMSNotCalc = kFALSE;
-   }
-  return fGammaLCMS;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetGammaToTransverse()
-{
-  //calculates gamma factor of the boost to LCMS
-  Double_t beta = 2.0*GetKt() / GetMt();
-  Double_t gamma = 1.0/TMath::Sqrt(1.0 - beta*beta);
-
-  return gamma;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetMt()
-{
-  //Calculates transverse mass of the pair
-  if (fMtNotCalc)
-   {
-     CalculateSums();
-     fMt = TMath::Sqrt(fESum*fESum - fPzSum*fPzSum);
-     fMtNotCalc = kFALSE;
-   }
-   return fMt;
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetAvarageDistance()
-{
-//returns and buffers avarage distance between two tracks calculated 
-// out of track points (see AliAODTrackPoints class)
-
-  if (fAvarageDistanceNotCalc)
-   {
-     fAvarageDistance = AvDistance();
-     fAvarageDistanceNotCalc = kFALSE;
-   }
-  return fAvarageDistance;
-}
-/************************************************************************/
-
-Double_t AliAODPair::AvDistance()
-{
-  //returns avarage distance between two tracks in range 
-  //as defined in Track-Points of AliVAODParticle
-  //returns negative value if error uccured f.g. tracks do not have track-points
-  AliTrackPoints* tpts1 = fPart1->GetTPCTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-
-  AliTrackPoints* tpts2 = fPart2->GetTPCTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-
-  return tpts1->AvarageDistance(*tpts2);
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetR() 
-{
-//Returns distance between particles vertexes in thir CMS
-
-  CalculateDiffs();
-  
-  Double_t  vxDiff = fPart1->Vx() - fPart2->Vx();
-  Double_t  vyDiff = fPart1->Vy() - fPart2->Vy();
-  Double_t  vzDiff = fPart1->Vz() - fPart2->Vz();
-  
-  Double_t r = TMath::Sqrt( vxDiff*vxDiff + vyDiff*vyDiff + vzDiff*vzDiff );
-  return r;
-  
-}
-/************************************************************************/
-
-Double_t AliAODPair::GetRStar() 
-{
-//Returns distance between particles vertexes in thir CMS
-
-
-  CalculateSums();
-
-  Double_t klen =    fPxSum*fPxSum  + fPySum*fPySum  + fPzSum*fPzSum;
-  klen = TMath::Sqrt(klen);
-
-  Double_t aBeta  = klen/fESum;
-  Double_t aGamma = 1.0/TMath::Sqrt(1.0 - aBeta*aBeta);
-
-
-  Double_t alpha = -TMath::ATan2(fPySum,fPzSum);
-  Double_t beta =  TMath::ATan2(fPxSum,TMath::Hypot(fPySum,fPzSum));
-
-  Double_t sinalpha = TMath::Sin(alpha);
-  Double_t cosalpha = TMath::Cos(alpha);
-  Double_t sinbeta = TMath::Sin(beta);
-  Double_t cosbeta = TMath::Cos(beta);
-
-  Double_t v1xP = fPart1->Vx();
-  Double_t v2xP = fPart2->Vx();
-  Double_t v1yP = fPart1->Vy()*cosalpha + fPart1->Vz()*sinalpha;
-  Double_t v2yP = fPart2->Vy()*cosalpha + fPart2->Vz()*sinalpha;
-  Double_t v1zP =-fPart1->Vy()*sinalpha + fPart1->Vz()*cosalpha;
-  Double_t v2zP =-fPart2->Vy()*sinalpha + fPart2->Vz()*cosalpha;
-
-
-///////////////////////////////////////////////////
-
-//  Double_t p1yP = fPart1->Py()*cosalpha + fPart1->Pz()*sinalpha;
-//  Double_t p2yP = fPart2->Py()*cosalpha + fPart2->Pz()*sinalpha;
-//
-//  Double_t p1zP =-fPart1->Py()*sinalpha + fPart1->Pz()*cosalpha;
-//  Double_t p2zP =-fPart2->Py()*sinalpha + fPart2->Pz()*cosalpha;
-//
-//
-//  Double_t p1x = fPart1->Px()*cosbeta - p1zP*sinbeta;
-//  Double_t p2x = fPart2->Px()*cosbeta - p2zP*sinbeta;
-//  Double_t p1z = fPart1->Px()*sinbeta + p1zP*cosbeta;
-//  Double_t p2z = fPart2->Px()*sinbeta + p2zP*cosbeta;
-
-//  Info("","%f %f %f",p1yP,p2yP,p1yP+p2yP);
-//  Info("","%f %f %f",p1x,p2x,p1x+p2x);
-  
-//  Info("","%f %f ",p1x+p2x,p1yP+p2yP);
-  
-///////////////////////////////////////////////////
-  
-
-  Double_t v1x = v1xP*cosbeta - v1zP*sinbeta;
-  Double_t v2x = v2xP*cosbeta - v2zP*sinbeta;
-  Double_t v1y = v1yP;
-  Double_t v2y = v2yP;
-  Double_t v1z = v1xP*sinbeta + v1zP*cosbeta;
-  Double_t v2z = v2xP*sinbeta + v2zP*cosbeta;
-
-
-  Double_t v1zB=aGamma*(v1z-aBeta*fPart1->T());
-  Double_t v2zB=aGamma*(v2z-aBeta*fPart2->T());
-
-
-  
-  Double_t dx = v1x - v2x;
-  Double_t dy = v1y - v2y;
-  Double_t dz = v1zB - v2zB;
-  
-  Double_t rstar = TMath::Sqrt( dx*dx + dy*dy + dz*dz);
-
-  return rstar;
-}
-/************************************************************************/
-
-void   AliAODPair::MirrorSecond()
-{
-//makes local copy of the second particle and mirrors their momenta
-//for its deletion is responsible who calls this method
-  fPart2 = (AliVAODParticle*)fPart2->Clone();
-  fPart2->SetMomentum(-fPart2->Px(),-fPart2->Py(),-fPart2->Pz(),fPart2->E());
-  Changed();
-}
-/************************************************************************/
-
-void   AliAODPair::DeleteSecond()
-{
-//Deletes second particle
-  delete fPart2;
-  fPart2 = 0x0;
-}
-
-void   AliAODPair::Print() 
-{
-  if (fPart1) fPart1->Print();
-  if (fPart2) fPart2->Print();
-  
-  Info("Print","GetKStar() %f",GetKStar());
-  Info("Print","GetKt() %f",GetKt() );
-  Info("Print","QInv %f", GetQInv() );
-  Info("Print","GetQOutLCMS() %f",GetQOutLCMS() );
-  Info("Print","GetQSideLCMS %f",GetQSideLCMS() );
-  Info("Print","GetQLongLCMS() %f", GetQLongLCMS());
-  Info("Print","GetDeltaTheta() %f", GetDeltaTheta());
-  Info("Print","GetDeltaPhi() %f", GetDeltaPhi());
-  
-  
-}
diff --git a/ANALYSIS/AliAODPair.h b/ANALYSIS/AliAODPair.h
deleted file mode 100644 (file)
index 5957f2a..0000000
+++ /dev/null
@@ -1,408 +0,0 @@
-#ifndef AliAODPair_H
-#define AliAODPair_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-//_________________________________________________________________________
-///////////////////////////////////////////////////////////////////////////
-//
-// class AliAODPair
-//
-// class implements pair of particles and taking care of caluclation (almost)
-// all of pair properties (Qinv, InvMass,...)
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
-//
-////////////////////////////////////////////////////////////////////////////
-
-#include <TMath.h>
-#include <TObject.h>
-
-#include "AliVAODParticle.h"
-
-class AliAODPair: public TObject
-{
- public:
-   AliAODPair(Bool_t rev = kFALSE); //contructor
-   AliAODPair(AliVAODParticle* part1, AliVAODParticle* part2, Bool_t rev = kFALSE); //contructor
-   AliAODPair(const AliAODPair& in);
-   
-   virtual ~AliAODPair(){}
-   
-   AliAODPair& operator=(const AliAODPair& in);
-   
-   void SetParticles(AliVAODParticle* p1,AliVAODParticle* p2); //sets particles in the pair
-   AliAODPair* GetSwappedPair() {return fSwappedPair;} //returns pair with swapped particles
-   
-   AliVAODParticle* Particle1() const {return fPart1;} //returns pointer to first particle
-   AliVAODParticle* Particle2() const {return fPart2;} //returns pointer to decond particle
-   
-   virtual void     Changed();
-   //Center Mass System - Longitudinally Comoving
-   
-   virtual Double_t GetInvMass(); //returns invariant mass of the pair
-   virtual Double_t GetMt();
-   virtual Double_t GetQInv(); //returns Q invariant
-   virtual Double_t GetQSideLCMS(); //returns Q Side CMS longitudionally co-moving
-   virtual Double_t GetQOutLCMS(); //returns Q out CMS longitudionally co-moving
-   virtual Double_t GetQLongLCMS(); //returns Q Long CMS longitudionally co-moving
-   virtual Double_t GetQtLCMS(); //returns Q transverse CMS longitudionally co-moving
-   
-   virtual Double_t GetQt(); //returns Q transverse to Kt
-   
-   
-   virtual Double_t GetKt();  //returns K transverse
-   virtual Double_t GetKStar();
-   virtual Double_t GetKStarOut();  //z.ch.
-   virtual Double_t GetKStarSide(); //z.ch.
-   virtual Double_t GetKStarLong(); //z.ch.
-   
-
-   virtual Double_t GetAvarageDistance();//returns avarage distnace between two tracks
-   
-   virtual Double_t GetDeltaE(); //return difference of Energies
-   virtual Double_t GetDeltaP(); //return difference of momenta (scalar difference)
-   virtual Double_t GetDeltaPvector(); //return legth of difference vector of momenta
-   virtual Double_t GetDeltaPt();
-   virtual Double_t GetDeltaPx();
-   virtual Double_t GetDeltaPy();
-   virtual Double_t GetDeltaPz();
-   
-   virtual Double_t GetDeltaTheta();
-   virtual Double_t GetDeltaPhi();
-   
-   virtual Double_t GetGammaToLCMS();
-   virtual Double_t GetGammaToTransverse();
-   virtual Double_t GetPIDProb() const {return fPart1->GetPidProb()*fPart2->GetPidProb();}
-   
-   virtual Double_t GetRStar() ;
-   virtual Double_t GetR() ;//returns distance between particle production points   
-   
-   void   MirrorSecond();
-   void   DeleteSecond();
-   
-   void   Print(const Option_t* option ) const {TObject::Print(option);}
-   void   Print() ;
-   
- protected:
-   AliVAODParticle* fPart1;  //pointer to first particle
-   AliVAODParticle* fPart2;  //pointer to second particle
-  
-   AliAODPair* fSwappedPair; //pointer to swapped pair
-   
-/************************************************************/
-/************CMS (LC) Q's   *********************************/
-/************************************************************/
-   //Center Mass System - Longitudinally Comoving
-   
-   Double_t fQSideLCMS;  //value of Q side CMS longitudially co-moving
-   Bool_t   fQSideLCMSNotCalc; //flag indicating if fQSideLCMS is already calculated for this pair
-   
-   Double_t fQOutLCMS; //value of Q out CMS longitudially co-moving
-   Bool_t   fQOutLCMSNotCalc;//flag indicating if fQOutLCMS is already calculated for this pair
-   
-   Double_t fQLongLCMS; //value of Q long CMS longitudially co-moving
-   Bool_t   fQLongLCMSNotCalc;//flag indicating if fQLongLCMS is already calculated for this pair
-   
-   Double_t fQtLCMS; //value of Qt CMS longitudially co-moving (hypot(qsidelcms,qoutlcms))
-   Bool_t   fQtLCMSNotCalc;//flag indicating if fQLongLCMS is already calculated for this pair
-
-   Double_t fQt; //value of Qt, projection of 3-mom diff to Kt
-   Bool_t   fQtNotCalc;//flag indicating if fQt is already calculated for this pair
-   
-/************************************************************/
-/************************************************************/
-   Double_t fQInv;  //half of differnece of 4-momenta
-   Bool_t   fQInvNotCalc;//flag indicating if fQInv is already calculated for this pair
-   
-   Double_t fInvMass;  //invariant mass
-   Bool_t   fInvMassNotCalc;//flag indicating if fInvMass is already calculated for this pair
-   
-   Double_t fKt; //K == sum vector of particle's momenta. Kt transverse component
-   Bool_t   fKtNotCalc;//flag indicating if fKt is already calculated for this pair
-   
-   Double_t fKStar; // KStar
-   Bool_t   fKStarNotCalc;// flag indicating if fKStar is calculated
-   Double_t fKStarOut; // KStarOut   z.ch.
-   Double_t fKStarSide;// KStarSide  z.ch.
-   Double_t fKStarLong;// KStarLong  z.ch.
-
-   Bool_t   fKStarCompNotCalc; // flag indicating if CalcuteKStarComp() is calculated  z.ch.
-
-   Double_t fPInv;  //invariant momentum
-   
-   Double_t fQSide; //Q Side
-   Double_t fOut;//Q Out
-   Double_t fQLong;//Q Long
-
-   Double_t fMt;//Transverse coordinate of Inv. Mass
-   Bool_t   fMtNotCalc;//flag indicating if Mt is calculated for current pair
-      
-   Double_t fInvMassSqr;//squre of invariant mass
-   Bool_t   fMassSqrNotCalc; //flag indicating if fInvMassSqr for this pair
-   void     CalculateInvMassSqr();
-   
-   Double_t fQInvL; //Qinv in longitudional direction
-   Bool_t   fQInvLNotCalc;//flag indicating if fQInvL is calculated for current pair
-   void     CalculateQInvL();
-
-   Double_t fAvarageDistance;//value of the avarage distance calculated out of track points
-   Bool_t   fAvarageDistanceNotCalc;//flag indicating if the avarage distance is calculated
-   
-   Double_t fPxSum;// Sum of Px momenta
-   Double_t fPySum;// Sum of Py momenta
-   Double_t fPzSum;// Sum of Pz momenta
-   Double_t fESum;// Sum of energies
-   Bool_t   fSumsNotCalc;//flag indicating if fPxSum,fPxSum,fPxSum and fESum is calculated for current pair
-   void     CalculateSums();
-   void     CalculateKStarComp();
-   
-   Double_t fPxDiff;// Difference of Px momenta
-   Double_t fPyDiff;// Difference of Px momenta
-   Double_t fPzDiff;// Difference of Px momenta
-   Double_t fEDiff;// Difference of Px momenta
-   Bool_t   fDiffsNotCalc;//flag indicating if fPxDiff,fPxDiff,fPxDiff and fEDiff is calculated for current pair
-   void     CalculateDiffs();
-   
-   Double_t fGammaLCMS;//gamma of boost in LCMS
-   Bool_t   fGammaLCMSNotCalc;//flag indicating if fGammaLCMS is calculated for current pair
-   /***************************************************/
-   Bool_t   fChanged;//flag indicating if object has been changed
-
-   void     CalculateBase();
-   Double_t AvDistance();
-   
-   
- private:
-  ClassDef(AliAODPair,1)
-};
-/****************************************************************/
-inline
-void AliAODPair::SetParticles(AliVAODParticle* p1,AliVAODParticle* p2)
-{
- //sets the particle to the pair
- fPart1 = p1; 
- fPart2 = p2;
- if (fSwappedPair) //if we have Swapped (so we are not)
-   fSwappedPair->SetParticles(fPart2,p1); //set particles for him too
- Changed();
- //and do nothing until will be asked for
-} 
-/****************************************************************/
-
-inline
-void AliAODPair::Changed()
-{
- // Resel all calculations (flags)
- fChanged           = kTRUE;
- fSumsNotCalc       = kTRUE;
- fDiffsNotCalc      = kTRUE;
- fMassSqrNotCalc    = kTRUE;
- fInvMassNotCalc    = kTRUE;
- fQInvNotCalc       = kTRUE;
- fMtNotCalc         = kTRUE;
- fQSideLCMSNotCalc = kTRUE;
- fQOutLCMSNotCalc  = kTRUE;
- fQLongLCMSNotCalc = kTRUE;
- fQtLCMSNotCalc    = kTRUE;
- fQtNotCalc        = kTRUE;
- fKtNotCalc         = kTRUE;
- fKStarNotCalc      = kTRUE;
- fKStarCompNotCalc  = kTRUE;
- fQInvLNotCalc      = kTRUE;
- fGammaLCMSNotCalc = kTRUE;
- fAvarageDistanceNotCalc = kTRUE;
-}
-/****************************************************************/
-inline 
-void AliAODPair::CalculateInvMassSqr()
- {
-  //calculates square of qinv
-  if (fMassSqrNotCalc)
-   {
-     CalculateSums();
-     Double_t fPart12s= (fPxSum*fPxSum) + (fPySum*fPySum) + (fPzSum*fPzSum);
-     fInvMassSqr=fESum*fESum-fPart12s;
-
-     fMassSqrNotCalc = kFALSE;
-   }
- }
-/****************************************************************/
-inline 
-void AliAODPair::CalculateQInvL()
- {
- //Calculates square root of Qinv
-  if (fQInvLNotCalc)
-  {
-   CalculateDiffs();
-   fQInvL = fEDiff*fEDiff - ( fPxDiff*fPxDiff + fPyDiff*fPyDiff + fPzDiff*fPzDiff );
-   fQInvLNotCalc = kFALSE;
-  }
- }
-/****************************************************************/ 
-inline 
-void AliAODPair::CalculateSums()
- {
-   //calculates momenta and energy sums
-   if(fSumsNotCalc)
-    {
-     fPxSum = fPart1->Px()+fPart2->Px();
-     fPySum = fPart1->Py()+fPart2->Py();
-     fPzSum = fPart1->Pz()+fPart2->Pz();
-     fESum  = fPart1->E() + fPart2->E();
-     fSumsNotCalc = kFALSE;
-    }
- }
-/****************************************************************/
-inline
-void AliAODPair::CalculateKStarComp()
-{
-  
-  if (fKStarCompNotCalc)
-    {
-      CalculateSums();
-
-      Double_t ptrans = fPxSum*fPxSum + fPySum*fPySum;
-      Double_t mtrans = fESum*fESum - fPzSum*fPzSum;
-      Double_t pinv  =  TMath::Sqrt(mtrans - ptrans);
-      ptrans         =  TMath::Sqrt(ptrans);
-      mtrans         =  TMath::Sqrt(mtrans);
-      
-      Double_t px1   = fPart1->Px();
-      Double_t py1   = fPart1->Py();
-      Double_t pz1   = fPart1->Pz();
-      Double_t pE1   = fPart1->E();
-
-      // boost to LCMS
-      Double_t beta  = fPzSum / fESum;
-      Double_t gamma = fESum / mtrans;
-
-      fKStarLong     = gamma * (pz1 - beta * pE1);
-      double   temp  = gamma * (pE1 - beta * pz1);
-
-      // rotate in transverse plane
-      fKStarSide = (-px1*fPySum + py1*fPxSum)/ptrans;
-      fKStarOut  = ( px1*fPxSum + py1*fPySum)/ptrans;
-      // go from LCMS to CMS
-      gamma = mtrans/pinv;
-      beta  = ptrans/mtrans;
-      fKStarOut  = gamma * (fKStarOut - beta * temp);
-
-      fKStarCompNotCalc = kFALSE;
-    }
-}
-
-/****************************************************************/
-inline 
-void AliAODPair::CalculateDiffs()
- {
-   //calculates momenta and energy differences 
-   if(fDiffsNotCalc)
-    {
-     fPxDiff = fPart1->Px()-fPart2->Px();
-     fPyDiff = fPart1->Py()-fPart2->Py();
-     fPzDiff = fPart1->Pz()-fPart2->Pz();
-     fEDiff  = fPart1->E() - fPart2->E();
-     fDiffsNotCalc = kFALSE;
-    }
- }
-
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaE() 
-{
- //returns difference of energies
-  return fPart1->E() - fPart2->E();
-}
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaP() 
-{
- //returns difference of momenta (scalars)
- return fPart1->P() - fPart2->P();
-}
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaPvector() //return difference of momenta
-{
- //returns legth of the momenta difference vector 
- CalculateDiffs();
- return TMath::Sqrt(fPxDiff*fPxDiff + fPyDiff*fPyDiff + fPzDiff*fPzDiff);
-}
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaPt()
- {
-   //returns difference of Pz
-   return fPart1->Pt()-fPart2->Pt();
- }
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaPx()
- {
-   //returns difference of Pz
-   CalculateDiffs();
-   return fPxDiff;
- }
-/****************************************************************/
-inline 
-Double_t AliAODPair::GetDeltaPy()
- {
-   //returns difference of Py
-   CalculateDiffs();
-   return fPyDiff;
- }
-
-/****************************************************************/
-inline 
-Double_t AliAODPair::GetDeltaPz()
- {
-   //returns difference of Pz
-   CalculateDiffs();
-   return fPzDiff;
- }
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaPhi()
- {
-   //returns difference of Phi
-   Double_t phi1 = fPart1->Phi();
-   Double_t phi2 = fPart2->Phi();
-   Double_t diff = phi1-phi2;
-   if (TMath::Abs(diff) > TMath::Pi())
-    {
-      if (phi1 > TMath::Pi())
-       {
-         phi1-=TMath::TwoPi();
-       }
-      else
-       {
-         phi2-=TMath::TwoPi();
-       }
-      diff = phi1-phi2; 
-    }
-   return diff;
- }
-/****************************************************************/
-
-inline 
-Double_t AliAODPair::GetDeltaTheta()
- {
-   //returns difference of Theta
-   return fPart1->Theta()-fPart2->Theta();
- }
-/****************************************************************/
-
-
-#endif
diff --git a/ANALYSIS/AliAODPairBaseCut.cxx b/ANALYSIS/AliAODPairBaseCut.cxx
deleted file mode 100644 (file)
index 0963581..0000000
+++ /dev/null
@@ -1,307 +0,0 @@
-// Base class AliAODPairBaseCut:
-// This class defines the range of some property - pure virtual
-// Property is coded by AliAODCutTypes type
-// Derived classes:
-//       AliAODQInvCut
-//       AliAODKtCut
-//       AliAODKStarCut
-//       AliAODKStarOutCut
-//       AliAODKStarSideCut
-//       AliAODKStarLongCut
-//       AliAODQSideLCMSCut
-//       AliAODQOutLCMSCut
-//       AliAODQLongLCMSCut
-//       AliAODDeltaECut
-//       AliAODDeltaPCut
-//       AliAODDeltaPvectorCut
-//       AliAODDeltaPhiCut
-//       AliAODDeltaThetaCut
-//       AliAODCluterOverlapCut
-//       AliAODAvSeparationCut
-//       AliAODSeparationCut
-//       AliAODITSSeparationCut
-//       AliAODOutSideSameSignCut
-//       AliAODOutSideDiffSignCut
-//       AliAODLogicalOperPairCut
-//       AliAODOrPairCut
-//       AliAODAndPairCut
-// Author: Piotr.Skowronski@cern.ch
-#include "AliAODPairBaseCut.h"
-
-#include "AliTrackPoints.h"
-#include "AliClusterMap.h"
-
-
-ClassImp(AliAODPairBaseCut)
-ClassImp(AliAODQInvCut)
-ClassImp(AliAODKtCut)
-ClassImp(AliAODQSideLCMSCut)
-ClassImp(AliAODQOutLCMSCut)
-ClassImp(AliAODQLongLCMSCut)
-ClassImp(AliAODDeltaECut)
-ClassImp(AliAODDeltaPCut)
-ClassImp(AliAODDeltaPvectorCut)
-ClassImp(AliAODDeltaPhiCut)
-ClassImp(AliAODDeltaThetaCut)
-
-/******************************************************************/
-ClassImp(AliAODAvSeparationCut)
-    
-Double_t AliAODAvSeparationCut::GetValue(AliAODPair* pair) const 
-{
-  //chacks if avarage distance of two tracks is in given range
-  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-
-  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-   
-  return tpts1->AvarageDistance(*tpts2);
-}
-/******************************************************************/
-ClassImp(AliAODSeparationCut)
-    
-Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const 
-{
-  //chacks if avarage distance of two tracks is in given range
-  AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-//     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-
-  AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-//     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
-     return -1.0;
-   }
-  Float_t x1=0,y1=0,z1=0; 
-  Float_t x2=0,y2=0,z2=0;
-  
-  tpts1->PositionAt(fPoint,x1,y1,z1);
-  tpts2->PositionAt(fPoint,x2,y2,z2);
-  Double_t dx1 = x1 - x2;
-  Double_t dy1 = y1 - y2;
-  Double_t dz1 = z1 - z2;
-  Double_t d = TMath::Sqrt(dx1*dx1 + dy1*dy1 + dz1*dz1);
-  return d;
-}
-/******************************************************************/
-
-ClassImp(AliAODITSSeparationCut)
-
-Bool_t AliAODITSSeparationCut::Rejected(AliAODPair* pair) const
-{
- //Checks if two tracks do not cross first pixels too close to each other
- //If two tracks use the same cluster in pixels they are given
- //the same position what skews theta angles (both are the same)
- //These guys create artificial correlation in non-id analyses
- //which is positive for identical polar angles (Qlong=0) 
- //and negative for a little bit different theta angle (Qlong=epsilon)
- //Such tracks "attracks" each other.
-  AliTrackPoints* tpts1 = pair->Particle1()->GetITSTrackPoints();
-  if ( tpts1 == 0x0)
-   {//it could be simulated pair
-     Warning("Pass","Track 1 does not have ITS Track Points. Pair NOT Passed.");
-     return kTRUE;//reject 
-   }
-
-  AliTrackPoints* tpts2 = pair->Particle2()->GetITSTrackPoints();
-  if ( tpts2 == 0x0)
-   {
-     Warning("Pass","Track 2 does not have ITS Track Points. Pair NOT Passed.");
-     return kTRUE;//reject 
-   }
-  Float_t  x1=0.0,y1=0.0,z1=0.0,x2=0.0,y2=0.0,z2=0.0;
-  tpts1->PositionAt(fLayer,x1,y1,z1);
-  tpts2->PositionAt(fLayer,x2,y2,z2);
-  
-//  Info("Pass","rphi %f z %f",fMin,fMax);
-//  Info("Pass","P1: %f %f %f", x1,y1,z1);
-//  Info("Pass","P2: %f %f %f", x2,y2,z2);
-  
-  Double_t dz = TMath::Abs(z1-z2);
-  
-  //fMax encodes treshold valaue of distance in Z
-  if (dz > fMax) return kFALSE;//pair accepted
-  
-  Double_t drphi = TMath::Hypot(x1-x2,y1-y2);
-  
-  //fMin encodes treshold valaue of distance in r-phi
-  if (drphi > fMin) return kFALSE;
-  
-  return kTRUE;//they are too close, rejected
-}
-/******************************************************************/
-
-ClassImp(AliAODCluterOverlapCut)
-
-Double_t  AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
-{
-  //Returns Cluter Overlap Factor
-  //It ranges between -0.5 (in all padrows both tracks have cluters) 
-  // and 1 (in all padrows one track has cluter and second has not)
-  // When Overlap Factor is 1 this pair of tracks in highly probable to be
-  // splitted track: one particle that is recontructed twise
-
-  AliClusterMap* cm1 = pair->Particle1()->GetClusterMap();
-  if ( cm1 == 0x0)
-   {
-     Warning("GetValue","Track 1 does not have Cluster Map. Returning -0.5.");
-     return -.5;
-   }
-
-  AliClusterMap* cm2 = pair->Particle2()->GetClusterMap();
-  if ( cm2 == 0x0)
-   {
-     Warning("GetValue","Track 2 does not have Cluster Map. Returning -0.5.");
-     return -.5;
-   }
-  return cm1->GetOverlapFactor(*cm2);
-}
-/******************************************************************/
-ClassImp(AliAODOutSideSameSignCut)
-
-Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
-{
-  //returns kTRUE if pair DO NOT meet cut criteria
-  
-  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
-   {
-     return kFALSE;//accpeted
-   }
-
-  return kTRUE ;//rejected
-}
-/******************************************************************/
-ClassImp(AliAODOutSideDiffSignCut)
-
-Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
-{
-  //returns kTRUE if pair DO NOT meet cut criteria
-  
-  if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 ) 
-   {
-     return kTRUE;//rejected
-   }
-  
-  return kFALSE;//accepted
-}
-/******************************************************************/
-ClassImp( AliAODLogicalOperPairCut )
-
-AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
- AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
- fFirst(new AliAODDummyBasePairCut),
- fSecond(new AliAODDummyBasePairCut)
-{
- //ctor
-}
-/******************************************************************/
-
-AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):
- AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
- fFirst((first)?(AliAODPairBaseCut*)first->Clone():0x0),
- fSecond((second)?(AliAODPairBaseCut*)second->Clone():0x0)
-{
-  //ctor
-  //note that base cuts are copied, not just pointers assigned
-  if ( (fFirst && fSecond) == kFALSE) 
-   {
-     Fatal("AliAODLogicalOperPairCut","One of parameters is NULL!");
-   }
-}
-/******************************************************************/
-
-AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
-{
-  //destructor
-  delete fFirst;
-  delete fSecond;
-}
-/******************************************************************/
-
-Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Rejected(AliAODPair* /*pair*/)  const
-{
-  //checks if particles passes properties defined by this cut
-  Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
-  return kFALSE;//accept
-}
-/******************************************************************/
-
-void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
-{
-  // Stream all objects in the array to or from the I/O buffer.
-  UInt_t R__s, R__c;
-  if (b.IsReading()) 
-   {
-     delete fFirst;
-     delete fSecond;
-     fFirst  = 0x0;
-     fSecond = 0x0;
-
-     b.ReadVersion(&R__s, &R__c);
-     TObject::Streamer(b);
-     b >> fFirst;
-     b >> fSecond;
-     b.CheckByteCount(R__s, R__c,AliAODLogicalOperPairCut::IsA());
-   } 
-  else 
-   {
-     R__c = b.WriteVersion(AliAODLogicalOperPairCut::IsA(), kTRUE);
-     TObject::Streamer(b);
-     b << fFirst;
-     b << fSecond;
-     b.SetByteCount(R__c, kTRUE);
-  }
-}
-
-/******************************************************************/
-ClassImp(AliAODOrPairCut)
-
-Bool_t AliAODOrPairCut::Rejected(AliAODPair * p) const
-{
-  //returns true when rejected 
-  //AND operation is a little bit misleading but is correct
-  //User wants to build logical cuts with natural (positive) logic
-  //while ALIAN use inernally reverse (returns true when rejected)
-  if (fFirst->Rejected(p) && fSecond->Rejected(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
-  return kFALSE;//accepted, at least one accepted (returned kFALSE)
-}
-/******************************************************************/
-
-ClassImp(AliAODAndPairCut)
-
-Bool_t AliAODAndPairCut::Rejected(AliAODPair * p)  const
-{
-  //returns true when rejected 
-  //OR operation is a little bit misleading but is correct
-  //User wants to build logical cuts with natural (positive) logic
-  //while ALIAN use inernally reverse (returns true when rejected)
-  if (fFirst->Rejected(p))
-   {//first rejected - we reject
-     return kTRUE;
-   }
-  else
-   {//first accepted
-    if (fSecond->Rejected(p))
-     {//second rejected - we reject
-       return kTRUE;
-     }
-   }  
-//  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
-  
-  return kFALSE;//accepted (both accepted (returned kFALSE))
-}
-/******************************************************************/
diff --git a/ANALYSIS/AliAODPairBaseCut.h b/ANALYSIS/AliAODPairBaseCut.h
deleted file mode 100644 (file)
index 262604b..0000000
+++ /dev/null
@@ -1,415 +0,0 @@
-#ifndef ALIAODPAIRBASECUT_H
-#define ALIAODPAIRBASECUT_H
-// Base class AliAODPairBaseCut:
-// This class defines the range of some property - pure virtual
-// Property is coded by AliAODCutTypes type
-// Derived classes:
-//       AliAODQInvCut
-//       AliAODKtCut
-//       AliAODKStarCut
-//       AliAODKStarOutCut
-//       AliAODKStarSideCut
-//       AliAODKStarLongCut
-//       AliAODQSideLCMSCut
-//       AliAODQOutLCMSCut
-//       AliAODQLongLCMSCut
-//       AliAODDeltaECut
-//       AliAODDeltaPCut
-//       AliAODDeltaPvectorCut
-//       AliAODDeltaPhiCut
-//       AliAODDeltaThetaCut
-//       AliAODCluterOverlapCut
-//       AliAODAvSeparationCut
-//       AliAODSeparationCut
-//       AliAODITSSeparationCut
-//       AliAODOutSideSameSignCut
-//       AliAODOutSideDiffSignCut
-//       AliAODLogicalOperPairCut
-//       AliAODOrPairCut
-//       AliAODAndPairCut
-
-#include <TObject.h> 
-#include "AliAODPair.h"
-
-
-class AliAODPairBaseCut: public TObject
-{
- public:
-
-  enum EAODPairCutProperty
-    {
-      kHbtPairCutPropQInv, //Q invariant
-      kHbtPairCutPropKt,
-      kHbtPairCutPropKStar,
-      kHbtPairCutPropKStarOut,
-      kHbtPairCutPropKStarSide,
-      kHbtPairCutPropKStarLong,
-      kHbtPairCutPropQSideLCMS,
-      kHbtPairCutPropQOutLCMS,
-      kHbtPairCutPropQLongLCMS,
-      kHbtPairCutPropDeltaPhi,
-      kHbtPairCutPropDeltaTheta,
-      kHbtPairCutPropDeltaE,
-      kHbtPairCutPropDeltaP,//scalar difference
-      kHbtPairCutPropDeltaPvector,//legth of the momenta difference vector
-      kHbtPairCutPropDeltaPt,
-      kHbtPairCutPropAvSepar,
-      kHbtPairCutPropSepar,
-      kHbtPairCutPropClOverlap,
-      kHbtPairCutPropPixelSepar,
-      kHbtPairCutPropNone
-    };
-
-  AliAODPairBaseCut(Double_t min = 0.0, Double_t max = 0.0, EAODPairCutProperty prop= kHbtPairCutPropNone):
-    fMin(min),fMax(max),fProperty(prop){}
-  
-  virtual   ~AliAODPairBaseCut(){}
-     
-  virtual Bool_t    Rejected(AliAODPair* pair) const;
-  
-  void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
-  
-  void      SetMinimum(Double_t min){fMin = min;}
-  void      SetMaximum(Double_t max){fMax = max;}
-  
-  Double_t  GetMinimum() const {return fMin;}
-  Double_t  GetMaximum() const {return fMax;}
-  
-  EAODPairCutProperty GetProperty() const {return fProperty;}
-  
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const = 0;
-  
-  Double_t fMin; // Lower boundary of the range
-  Double_t fMax; // Upper boundary of the range
-  
-  EAODPairCutProperty fProperty; // The property itself
-  
-  ClassDef(AliAODPairBaseCut,1)
- };
-/******************************************************************/
-
-inline Bool_t AliAODPairBaseCut::Rejected(AliAODPair* pair) const
-{
-  //checks if pair proprty is in range
-  //null pointer check is made by AliAODPairCut, so here is unnecesary
-  
-  Double_t value = GetValue(pair);
-  if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
-  else return kTRUE; //rejected
-}
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODQInvCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropQInv){}
-  virtual ~AliAODQInvCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetQInv();}
-  
-  ClassDef(AliAODQInvCut,1)
- };
-/******************************************************************/
-
-class AliAODKtCut: public AliAODPairBaseCut {
- public:
-  AliAODKtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKt){}
-  virtual ~AliAODKtCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKt();}
-
-  ClassDef(AliAODKtCut,1)
- };
-/******************************************************************/
-
-class AliAODKStarCut: public AliAODPairBaseCut
-{
- public:
-  AliAODKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStar){}
-  virtual ~AliAODKStarCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStar();}
-
-  ClassDef(AliAODKStarCut,1)
-};
-/******************************************************************/
-
-class AliAODKStarOutCut: public AliAODPairBaseCut
-{
- public:
-  AliAODKStarOutCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStarOut){}
-  virtual ~AliAODKStarOutCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStarOut();}
-
-  ClassDef(AliAODKStarOutCut,1)
-};
-/******************************************************************/
-class AliAODKStarSideCut: public AliAODPairBaseCut
-{
- public:
-  AliAODKStarSideCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStarSide){}
-  virtual ~AliAODKStarSideCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStarSide();}
-
-  ClassDef(AliAODKStarSideCut,1)
-};
-
-/******************************************************************/
-
-class AliAODKStarLongCut: public AliAODPairBaseCut
-{
- public:
-  AliAODKStarLongCut(Double_t min = 0.0, Double_t max = 0.0):AliAODPairBaseCut(min,max,kHbtPairCutPropKStarLong){}
-  virtual ~AliAODKStarLongCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const {return pair->GetKStarLong();}
-
-  ClassDef(AliAODKStarLongCut,1)
-};
-/******************************************************************/
-
-class AliAODQSideLCMSCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQSideLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropQSideLCMS){}
-  virtual ~AliAODQSideLCMSCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetQSideLCMS();}
-
-  ClassDef(AliAODQSideLCMSCut,1)
-};
-/******************************************************************/
-
-
-class AliAODQOutLCMSCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQOutLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropQOutLCMS){}
-  virtual ~AliAODQOutLCMSCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetQOutLCMS();}
-  
-  ClassDef(AliAODQOutLCMSCut,1)
-};
-/******************************************************************/
-
-class AliAODQLongLCMSCut: public AliAODPairBaseCut
-{
- public:
-  AliAODQLongLCMSCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropQLongLCMS){}
-  virtual ~AliAODQLongLCMSCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetQLongLCMS();}
-
-  ClassDef(AliAODQLongLCMSCut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaECut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaECut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaE){}
-  virtual ~AliAODDeltaECut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetDeltaE();}
-
-  ClassDef(AliAODDeltaECut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaPCut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaPCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaP){}
-  virtual ~AliAODDeltaPCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetDeltaP();}
-
-  ClassDef(AliAODDeltaPCut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaPvectorCut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaPvectorCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPvector){}
-  virtual ~AliAODDeltaPvectorCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return pair->GetDeltaPvector();}
-
-  ClassDef(AliAODDeltaPvectorCut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaPhiCut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaPhiCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaPhi){}
-  virtual ~AliAODDeltaPhiCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return TMath::Abs(pair->GetDeltaPhi());}
-
-  ClassDef(AliAODDeltaPhiCut,1)
-};
-/******************************************************************/
-
-class AliAODDeltaThetaCut: public AliAODPairBaseCut
-{
- public:
-  AliAODDeltaThetaCut(Double_t min = 0.0, Double_t max = 0.0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropDeltaTheta){}
-  virtual ~AliAODDeltaThetaCut(){}
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const 
-    {return TMath::Abs(pair->GetDeltaTheta());}
-
-  ClassDef(AliAODDeltaThetaCut,1)
-};
-/******************************************************************/
-
-class AliAODCluterOverlapCut: public AliAODPairBaseCut
-{
- public:
-  AliAODCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropClOverlap){}
-  virtual ~AliAODCluterOverlapCut(){}
-
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const;
-  ClassDef(AliAODCluterOverlapCut,1)
-};
-/******************************************************************/
-  
-class AliAODAvSeparationCut: public AliAODPairBaseCut
-{
- public:
-  AliAODAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropAvSepar){}
-  virtual ~AliAODAvSeparationCut(){}
-  
- protected:
-  virtual Double_t  GetValue(AliAODPair* pair) const;
-  ClassDef(AliAODAvSeparationCut,1)
-};
-/******************************************************************/
-  
-class AliAODSeparationCut: public AliAODPairBaseCut
-{
- public:
-  AliAODSeparationCut(Double_t min = 0.0, Double_t max = 1e5, Int_t point = 0):
-    AliAODPairBaseCut(min,max,kHbtPairCutPropSepar),fPoint(point){}
-  virtual ~AliAODSeparationCut(){}
-  
- protected:
-  Int_t fPoint;//index of the point that distance should be measured
-  virtual Double_t  GetValue(AliAODPair* pair) const;
-  ClassDef(AliAODSeparationCut,1)
-};
-/******************************************************************/
-  
-class AliAODITSSeparationCut: public AliAODPairBaseCut
-{
-//Anti merging cut for the first layer of pixels
- public:
-  AliAODITSSeparationCut(Int_t layer = 0, Double_t deltarphi = 0.01, Double_t deltaz = 0.08):
-    AliAODPairBaseCut(deltarphi,deltaz,kHbtPairCutPropPixelSepar),fLayer(layer){}
-  virtual ~AliAODITSSeparationCut(){}
-  Bool_t   Rejected(AliAODPair* pair) const;
-  Int_t    GetLayer() const {return fLayer;}
- protected:
-  Int_t fLayer;//index of the layer that distance should be measured 0: 1st pixels
-  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}//not used
-  ClassDef(AliAODITSSeparationCut,1)
-};
-/******************************************************************/
-
-class AliAODOutSideSameSignCut: public AliAODPairBaseCut
-{
- public:
-  AliAODOutSideSameSignCut(){}
-  virtual ~AliAODOutSideSameSignCut(){}
-  virtual Bool_t Rejected(AliAODPair *p) const;
- protected:
-  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-  ClassDef(AliAODOutSideSameSignCut,1)
-};
-/******************************************************************/
-
-class AliAODOutSideDiffSignCut: public AliAODPairBaseCut
-{
- public:
-  AliAODOutSideDiffSignCut(){}
-  virtual ~AliAODOutSideDiffSignCut(){}
-  virtual Bool_t Rejected(AliAODPair *p) const;
- protected:
-  virtual Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-  ClassDef(AliAODOutSideDiffSignCut,1)
-};
-/******************************************************************/
-
-class AliAODLogicalOperPairCut:  public AliAODPairBaseCut
- {
-   public:
-     AliAODLogicalOperPairCut();
-     AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second);
-     virtual   ~AliAODLogicalOperPairCut();
-   protected:
-     Double_t  GetValue(AliAODPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
-
-     AliAODPairBaseCut* fFirst;   //second cut
-     AliAODPairBaseCut* fSecond;  //first cut
-   private:
-     AliAODLogicalOperPairCut(const AliAODLogicalOperPairCut & src);
-     AliAODLogicalOperPairCut & operator=(const AliAODLogicalOperPairCut & src);
-    class  AliAODDummyBasePairCut: public AliAODPairBaseCut
-     {
-       Double_t  GetValue(AliAODPair* /*pair*/) const {return 0.0;}
-       Bool_t    Rejected(AliAODPair* /*pair*/) const;
-     };
-
-    ClassDef(AliAODLogicalOperPairCut,1)
- };
-/******************************************************************/
-
-class AliAODOrPairCut: public AliAODLogicalOperPairCut
-{
-   public:
-     AliAODOrPairCut(){}
-     AliAODOrPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
-     virtual   ~AliAODOrPairCut(){}
-     Bool_t    Rejected(AliAODPair *p) const;
-     ClassDef(AliAODOrPairCut,1)
-};
-/******************************************************************/
-
-class AliAODAndPairCut: public AliAODLogicalOperPairCut
-{
-   public:
-     AliAODAndPairCut(){}
-     AliAODAndPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):AliAODLogicalOperPairCut(first,second){}
-     virtual   ~AliAODAndPairCut(){}
-     Bool_t    Rejected(AliAODPair *p) const;
-     ClassDef(AliAODAndPairCut,1)
-};
-
-#endif
diff --git a/ANALYSIS/AliAODPairCut.cxx b/ANALYSIS/AliAODPairCut.cxx
deleted file mode 100644 (file)
index 258cf9c..0000000
+++ /dev/null
@@ -1,402 +0,0 @@
-#include "AliAODPairCut.h"
-/* $Id$ */
-
-/////////////////////////////////////////////////////////////////////////
-//
-// Class AliAODPairCut:
-// implements cut on the pair of particles
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
-// Author: Piotr.Skowronski@cern.ch
-//-------------------------------------------------------------------
-
-#include "AliAODPair.h"
-#include "AliAODParticleCut.h"
-//#include "AliTrackPoints.h"
-//#include "AliClusterMap.h"
-
-ClassImp(AliAODPairCut)
-const Int_t AliAODPairCut::fgkMaxCuts = 50;
-/**********************************************************/
-
-AliAODPairCut::AliAODPairCut():
-  fFirstPartCut(new AliAODParticleEmptyCut()), //empty cuts
-  fSecondPartCut(new AliAODParticleEmptyCut()), //empty cuts
-  fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
-  fNCuts(0)
-{
-  //constructor
-    
-  for (Int_t i = 0;i<fNCuts;i++)
-   {
-     fCuts[i] = 0x0;
-   }
-}
-/**********************************************************/
-
-AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
-  TNamed(in),
-  fFirstPartCut((AliAODParticleCut*)in.fFirstPartCut->Clone()),
-  fSecondPartCut((AliAODParticleCut*)in.fSecondPartCut->Clone()),
-  fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
-  fNCuts(in.fNCuts)
-{
-  //copy constructor
-
-  for (Int_t i = 0;i<fNCuts;i++)
-    {
-      fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
-    }
-}
-/**********************************************************/
-
-AliAODPairCut&  AliAODPairCut::operator=(const AliAODPairCut& in)
-{
-  //assignment operator
-  fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
-  fNCuts = in.fNCuts;
-
-  fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
-  fSecondPartCut = (AliAODParticleCut*)in.fSecondPartCut->Clone();
-  for (Int_t i = 0;i<fNCuts;i++)
-    {
-      fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
-    }
-  return * this;
-}
-/**********************************************************/
-
-AliAODPairCut::~AliAODPairCut()
-{
-  //destructor
-  if (fFirstPartCut != fSecondPartCut)
-    {
-      delete fSecondPartCut;
-    }
-  delete fFirstPartCut;
-  for (Int_t i = 0;i<fNCuts;i++)
-    {
-      delete fCuts[i];
-    }
-  delete []fCuts;
-} 
-/**********************************************************/
-
-/**********************************************************/
-
-void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
-{
-  //adds the base pair cut (cut on one value)
-  
-  if (!basecut) return;
-  if( fNCuts == (fgkMaxCuts-1) )
-    {
-      Warning("AddBasePairCut","Not enough place for another cut");
-      return;
-    }
-  fCuts[fNCuts++]=basecut;
-}
-/**********************************************************/
-
-Bool_t AliAODPairCut::Rejected(AliAODPair* pair) const
-{
-  //methods which checks if given pair meets all criteria of the cut
-  //if it meets returns FALSE
-  //if NOT   returns    TRUE
-  if(!pair) 
-    {
-      Warning("Pass","No Pasaran! We never accept NULL pointers");
-      return kTRUE;
-    }
-  
-  //check particle's cuts
-  if( ( fFirstPartCut->Rejected( pair->Particle1()) ) || 
-      ( fSecondPartCut->Rejected(pair->Particle2()) )   )
-    {  
-      return kTRUE;
-    }
-  return PassPairProp(pair);
-}
-/**********************************************************/
-
-Bool_t AliAODPairCut::PassPairProp(AliAODPair* pair) const
-{
-  //methods which checks if given pair meets all criteria of the cut
-  //if it meets returns FALSE
-  //if NOT   returns    TRUE
-  //examine all base pair cuts
-  for (Int_t i = 0;i<fNCuts;i++)
-    {
-      if ( (fCuts[i]->Rejected(pair)) ) return kTRUE; //if one of the cuts reject, then reject
-    }
-  return kFALSE;
-}
-/**********************************************************/
-
-void AliAODPairCut::Print()
-{
- //Prints the cut
-  for (Int_t i = 0;i<fNCuts;i++)
-    {
-      fCuts[i]->Dump();
-    }
-}
-/**********************************************************/
-
-void AliAODPairCut::SetFirstPartCut(AliAODParticleCut* cut)
-{
-  // set cut for the first particle
-  if(!cut) 
-    {
-      Error("SetFirstPartCut","argument is NULL");
-      return;
-    }
-  delete fFirstPartCut;
-  fFirstPartCut = (AliAODParticleCut*)cut->Clone();
-  
-}
-/**********************************************************/
-
-void AliAODPairCut::SetSecondPartCut(AliAODParticleCut* cut)
-{
-  // set cut for the second particle
-  if(!cut) 
-    {
-      Error("SetSecondPartCut","argument is NULL");
-      return;
-    }
-  delete fSecondPartCut;
-  fSecondPartCut = (AliAODParticleCut*)cut->Clone();
-}
-/**********************************************************/
-
-void AliAODPairCut::SetPartCut(AliAODParticleCut* cut)
-{
-  //sets the the same cut on both particles
-  if(!cut) 
-    {
-      Error("SetFirstPartCut","argument is NULL");
-      return;
-    }
-  if (fFirstPartCut == fSecondPartCut) fSecondPartCut = 0x0;
-  
-  delete fFirstPartCut;
-  fFirstPartCut = (AliAODParticleCut*)cut->Clone();
-  
-  delete fSecondPartCut; //even if null should not be harmful
-  fSecondPartCut = fFirstPartCut;
-}
-/**********************************************************/
-
-void AliAODPairCut::SetQInvRange(Double_t min, Double_t max)
-{
-  // set range of accepted invariant masses
-  AliAODQInvCut* cut= (AliAODQInvCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQInv);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODQInvCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetQOutLCMSRange(Double_t min, Double_t max)
-{
-  // set range of accepted QOut in CMS
-  AliAODQOutLCMSCut* cut= (AliAODQOutLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQOutLCMS);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODQOutLCMSCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetQSideLCMSRange(Double_t min, Double_t max)
-{
-  // set range of accepted QSide in CMS
-  AliAODQSideLCMSCut* cut= (AliAODQSideLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQSideLCMS);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODQSideLCMSCut(min,max);
-}
-
-/**********************************************************/
-
-void AliAODPairCut::SetQLongLCMSRange(Double_t min, Double_t max)
-{
-  // set range of accepted QLong in CMS
-  AliAODQLongLCMSCut* cut= (AliAODQLongLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQLongLCMS);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODQLongLCMSCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetDeltaERange(Double_t min, Double_t max)
-{
-  // set range of accepted DeltaE
-  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaE);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODDeltaECut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetDeltaPRange(Double_t min, Double_t max)
-{
-  // set range of accepted DeltaP
-  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaP);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODDeltaPCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetKtRange(Double_t min, Double_t max)
-{
-  // set range of accepted Kt (avarage transverse pair momentum)
-  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKt);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODKtCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetKStarRange(Double_t min, Double_t max)
-{
-  // set range of accepted KStar (invariant pair momentum difference (fourvector))
-  AliAODKStarCut* cut= (AliAODKStarCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStar);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODKStarCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetKStarOutRange(Double_t min, Double_t max)
-{
-  // set range of accepted KStar (invariant pair momentum difference (fourvector))
-  AliAODKStarOutCut* cut= (AliAODKStarOutCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarOut);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODKStarOutCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetKStarSideRange(Double_t min, Double_t max)
-{
-  // set range of accepted KStar (invariant pair momentum difference (fourvector))
-  AliAODKStarSideCut* cut= (AliAODKStarSideCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarSide);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODKStarSideCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetKStarLongRange(Double_t min, Double_t max)
-{
-  // set range of accepted KStar (invariant pair momentum difference (fourvector))
-  AliAODKStarLongCut* cut= (AliAODKStarLongCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarLong);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODKStarLongCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
-{
-  //sets avarage separation cut ->Anti-Merging cut
-  AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropAvSepar);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetITSSeparation(Int_t layer, Double_t drphi, Double_t dz)
-{
-  //Anti-Merging Cut for first pixel layer
-  AliAODITSSeparationCut* cut= dynamic_cast<AliAODITSSeparationCut*>(FindCut(AliAODPairBaseCut::kHbtPairCutPropPixelSepar));
-  if(cut) 
-   {
-     if (layer == cut->GetLayer())
-      {
-        cut->SetRange(drphi,dz);//In this cut fMin is drphi, and fMax dz
-        return;
-      }
-   }
-  fCuts[fNCuts++] = new AliAODITSSeparationCut(layer,drphi,dz);
-//  Info("SetITSSeparation","Added %d at address %#x",fNCuts-1,fCuts[fNCuts-1]);
-}
-/**********************************************************/
-
-void AliAODPairCut::SetClusterOverlapRange(Double_t min,Double_t max)
-{
-  //sets cluster overlap factor cut ->Anti-Splitting cut
-  //cluster overlap factor ranges between 
-  // -0.5 (in all padrows both tracks have cluters) 
-  // and 1 (in all padrows one track has cluter and second has not)
-  // When Overlap Factor is 1 this pair of tracks in highly probable to be
-  // splitted track: one particle that is recontructed twise
-  // STAR uses range from -0.5 to 0.6 
-  
-  AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropClOverlap);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
-}
-/**********************************************************/
-
-AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairBaseCut::EAODPairCutProperty property)
-{
-  // Find the cut corresponding to "property"
-  for (Int_t i = 0;i<fNCuts;i++)
-    {
-      if (fCuts[i]->GetProperty() == property) 
-       return fCuts[i]; //we found the cut we were searching for
-    }
-  
-  return 0x0; //we did not found this cut
-  
-}
-/**********************************************************/
-
-void AliAODPairCut::Streamer(TBuffer &b)
-{
-  // Stream all objects in the array to or from the I/O buffer.
-  
-  UInt_t R__s, R__c;
-  if (b.IsReading()) 
-    {
-      Version_t v = b.ReadVersion(&R__s, &R__c);
-      if (v > -1)
-       {
-          delete fFirstPartCut;
-          delete fSecondPartCut;
-          fFirstPartCut = 0x0;
-          fSecondPartCut = 0x0;
-          TObject::Streamer(b);
-          b >> fFirstPartCut;
-          b >> fSecondPartCut;
-          b >> fNCuts;
-          for (Int_t i = 0;i<fNCuts;i++)
-           {
-             b >> fCuts[i];
-           }
-        }
-      b.CheckByteCount(R__s, R__c,AliAODPairCut::IsA());
-    } 
-  else 
-    {
-      R__c = b.WriteVersion(AliAODPairCut::IsA(), kTRUE);
-      TObject::Streamer(b);
-      
-//      printf("Streamer Cut 1 %#x Cut 2 %#x\n",fFirstPartCut,fSecondPartCut);
-//      this->Dump();
-//      fFirstPartCut->Dump();
-      
-      b << fFirstPartCut;
-      b << fSecondPartCut;
-      b << fNCuts;
-      for (Int_t i = 0;i<fNCuts;i++)
-        {
-          b << fCuts[i];
-        }
-      b.SetByteCount(R__c, kTRUE);
-    }
-}
-/******************************************************************/
-
-ClassImp(AliAODPairEmptyCut)
-  
-void AliAODPairEmptyCut::Streamer(TBuffer &b)
-{
-//streamer for empty pair cut
-  AliAODPairCut::Streamer(b);
-}
-/******************************************************************/
-
diff --git a/ANALYSIS/AliAODPairCut.h b/ANALYSIS/AliAODPairCut.h
deleted file mode 100644 (file)
index b7c9066..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef ALIAODPAIRCUT_H
-#define ALIAODPAIRCUT_H
-
-/* $Id$ */
-
-//Piotr Skowronski@cern.ch
-//Class implements cut on the pair of particles
-//
-//more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
-
-#include <TNamed.h> 
-#include "AliAODPairBaseCut.h"
-
-class AliAODParticleCut;
-class AliAODPairBaseCut;
-
-/******************************************************************/
-
-class AliAODPairCut: public TNamed
-{
- public:
-  AliAODPairCut();
-  AliAODPairCut(const AliAODPairCut& in);
-  AliAODPairCut& operator = (const AliAODPairCut& in);
-  
-  virtual ~AliAODPairCut();
-  virtual Bool_t Rejected(AliAODPair* pair) const;
-  virtual Bool_t PassPairProp(AliAODPair* pair) const;
-     
-  virtual Bool_t IsEmpty() const {return kFALSE;}
-  void SetFirstPartCut(AliAODParticleCut* cut);  //sets the cut on the first particle
-  void SetSecondPartCut(AliAODParticleCut* cut); //sets the cut on the second particle
-  
-  void SetPartCut(AliAODParticleCut* cut);//sets the the same cut on both particles
-  
-  virtual void AddBasePairCut(AliAODPairBaseCut* cut);
-  
-  virtual void Print(const Option_t * opt) const {TNamed::Print(opt);}
-  virtual void Print();
-
-  void SetDeltaERange(Double_t min, Double_t max);
-  void SetDeltaPRange(Double_t min, Double_t max);
-  
-  void SetQInvRange(Double_t min, Double_t max);
-  void SetKtRange(Double_t min, Double_t max);
-  void SetKStarRange(Double_t min, Double_t max);
-  void SetKStarOutRange(Double_t min, Double_t max);
-  void SetKStarSideRange(Double_t min, Double_t max);
-  void SetKStarLongRange(Double_t min, Double_t max);
-  void SetQOutLCMSRange(Double_t min, Double_t max);
-  void SetQSideLCMSRange(Double_t min, Double_t max);
-  void SetQLongLCMSRange(Double_t min, Double_t max);
-  void SetAvSeparationRange(Double_t min,Double_t max = 10e5);//Anti-Merging Cut
-  void SetITSSeparation(Int_t layer, Double_t drphi=0.01,Double_t dz = 0.08);//Anti-Merging Cut for first pixel layer
-  void SetClusterOverlapRange(Double_t min,Double_t max);//Anti-Splitting Max range -0.5 1.0
-      
-  AliAODParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
-  AliAODParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
-  
- protected:
-  AliAODParticleCut*      fFirstPartCut;//cut on first particle in pair
-  AliAODParticleCut*      fSecondPartCut;//cut on second particle in pair
-  
-  AliAODPairBaseCut** fCuts; //! array of poiters to base cuts
-  Int_t fNCuts;//Number of cuts in fCuts array
-  
-  
-  AliAODPairBaseCut* FindCut(AliAODPairBaseCut::EAODPairCutProperty cut);
- private:
-  static const Int_t fgkMaxCuts; // Max number of cuts
-  ClassDef(AliAODPairCut,2)
-};
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODPairEmptyCut:  public AliAODPairCut
-{
-  //Empty - it passes possitively all particles - it means returns always False
-  //Class describing cut on pairs of particles
- public:
-  AliAODPairEmptyCut(){};
-  AliAODPairEmptyCut(const AliAODPairEmptyCut& in):AliAODPairCut(in){};
-  virtual ~AliAODPairEmptyCut(){};
-  
-  Bool_t Rejected(AliAODPair*) const {return kFALSE;} //accpept everything
-  Bool_t IsEmpty() const {return kTRUE;}
-  
-  ClassDef(AliAODPairEmptyCut,1)
-};
-
-
-#endif
diff --git a/ANALYSIS/AliAODParticle.cxx b/ANALYSIS/AliAODParticle.cxx
deleted file mode 100644 (file)
index ea6f06e..0000000
+++ /dev/null
@@ -1,487 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-//___________________________________________________________
-/////////////////////////////////////////////////////////////
-//
-// class AliAODParticle
-//
-// Ali HBT Particle: simplified class TParticle
-// Simplified in order to minimize the size of object
-//  - we want to keep a lot of such a objects in memory
-// Additionaly adjusted for HBT Analysies purposes
-// + pointer to Track Points
-// + pointer to Cluster Map(s)
-//
-// Piotr.Skowronski@cern.ch
-//
-/////////////////////////////////////////////////////////////
-#include <TParticle.h>
-
-#include "AliAODParticle.h"
-#include "AliClusterMap.h"
-#include "AliLog.h"
-#include "AliTrackPoints.h"
-
-ClassImp(AliAODParticle)
-
-//______________________________________________________________________________
-AliAODParticle::AliAODParticle():  
- fPdgIdx(0), fIdxInEvent(0),fNPids(0),fPids(0x0),fPidProb(0x0),
- fCalcMass(0),fPx(0), fPy(0),fPz(0),fE(0), fVx(0), fVy(0),fVz(0),fVt(0),
- fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
-{//empty particle
-}
-//______________________________________________________________________________
-
-AliAODParticle::AliAODParticle(Int_t pdg, Int_t idx,
-               Double_t px, Double_t py, Double_t pz, Double_t etot,
-               Double_t vx, Double_t vy, Double_t vz, Double_t time):  
-  fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
-  fCalcMass(0), 
-  fPx(px), fPy(py),fPz(pz),fE(etot), 
-  fVx(vx), fVy(vy),fVz(vz),fVt(time),
-  fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
-{
-//mormal constructor
-  SetPdgCode(pdg);
-  if (GetPDG()) {
-     fCalcMass    = GetPDG()->Mass();
-  } else {
-     Double_t a2 = fE*fE -fPx*fPx -fPy*fPy -fPz*fPz;
-     if (a2 >= 0) fCalcMass =  TMath::Sqrt(a2);
-     else         fCalcMass = -TMath::Sqrt(-a2);
-  }
-}
-//______________________________________________________________________________
-
-AliAODParticle::AliAODParticle(Int_t pdg, Float_t prob, Int_t idx, 
-                               Double_t px, Double_t py, Double_t pz, Double_t etot,
-                               Double_t vx, Double_t vy, Double_t vz, Double_t time):
-  fPdgIdx(0), fIdxInEvent(idx),fNPids(0),fPids(0x0),fPidProb(0x0),
-  fCalcMass(0), 
-  fPx(px), fPy(py),fPz(pz),fE(etot), 
-  fVx(vx), fVy(vy),fVz(vz),fVt(time),
-  fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
-{
-//mormal constructor
-  SetPdgCode(pdg,prob);
-  if (GetPDG()) {
-     fCalcMass    = GetPDG()->Mass();
-  } else {
-     Double_t a2 = fE*fE -fPx*fPx -fPy*fPy -fPz*fPz;
-     if (a2 >= 0) fCalcMass =  TMath::Sqrt(a2);
-     else         fCalcMass = -TMath::Sqrt(-a2);
-  }
-}
-//______________________________________________________________________________
-
-AliAODParticle::AliAODParticle(const AliAODParticle& in):
-   AliVAODParticle(in),
-   fPdgIdx(in.fPdgIdx), fIdxInEvent(in.fIdxInEvent),
-   fNPids(in.fNPids),fPids(new Int_t[fNPids]),fPidProb(new Float_t[fNPids]),
-   fCalcMass(in.GetCalcMass()),
-   fPx(in.Px()),fPy(in.Py()),fPz(in.Pz()),fE(in.E()), 
-   fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T()),
-   fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
-{
- //Copy constructor
-// Info("AliAODParticle(const AliAODParticle& in)","");
- for(Int_t i = 0; i<fNPids; i++)
-  {
-    fPids[i] =  in.fPids[i];
-    fPidProb[i] = in.fPidProb[i];
-  }
- if (in.fTPCTrackPoints)
-   fTPCTrackPoints = (AliTrackPoints*)in.fTPCTrackPoints->Clone();
- if (in.fITSTrackPoints)
-   fITSTrackPoints = (AliTrackPoints*)in.fITSTrackPoints->Clone();
- if (in.fClusterMap)
-   fClusterMap = (AliClusterMap*)in.fClusterMap->Clone();
-}
-//______________________________________________________________________________
-
-AliAODParticle::AliAODParticle(const AliVAODParticle& in):
-   AliVAODParticle(in),
-   fPdgIdx(0), fIdxInEvent(in.GetUID()),
-   fNPids(0),fPids(0x0),fPidProb(0x0),
-   fCalcMass(-1.0),
-   fPx(in.Px()),fPy(in.Py()),fPz(in.Pz()),fE(in.E()), 
-   fVx(in.Vx()),fVy(in.Vy()),fVz(in.Vz()),fVt(in.T()),
-   fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
-{
- //Copy constructor
-// Info("AliAODParticle(const AliVAODParticle& in)","");
- for(Int_t i = 0; i<in.GetNumberOfPids(); i++)
-  {
-    SetPIDprobability(in.GetNthPid(i),in.GetNthPidProb(i));
-  }
- SetPdgCode(in.GetPdgCode(),in.GetPidProb());
- AliTrackPoints* tpts = in.GetTPCTrackPoints();
- if (tpts)  SetTPCTrackPoints((AliTrackPoints*)tpts->Clone());
- tpts = in.GetITSTrackPoints();  
- if (tpts) SetITSTrackPoints((AliTrackPoints*)tpts->Clone());
-   
- AliClusterMap* clmap = in.GetClusterMap();
- if (clmap) SetClusterMap((AliClusterMap*)clmap->Clone());
-}
-//______________________________________________________________________________
-
-AliAODParticle::AliAODParticle(const TParticle &p,Int_t idx):
-   fPdgIdx(0), fIdxInEvent(idx),
-   fNPids(0),fPids(0x0),fPidProb(0x0),
-   fCalcMass(p.GetCalcMass()),
-   fPx(p.Px()),fPy(p.Py()),fPz(p.Pz()),fE(p.Energy()), 
-   fVx(p.Vx()),fVy(p.Vy()),fVz(p.Vz()),fVt(p.T()),
-   fTPCTrackPoints(0x0),fITSTrackPoints(0x0),fClusterMap(0x0)
-{
- //all copied in the initialization
- SetPdgCode(p.GetPdgCode());
-}
-//______________________________________________________________________________
-
-AliAODParticle::~AliAODParticle()
-{
-//dtor  
-  delete [] fPids;
-  delete [] fPidProb;
-  delete fTPCTrackPoints;
-  delete fITSTrackPoints;
-  delete fClusterMap;
-}
-//______________________________________________________________________________
-
-void AliAODParticle::Clear(Option_t*)
-{
-//Must be implemented in order to store this object in Clones Array
-  delete [] fPids;
-  delete [] fPidProb;
-  delete fTPCTrackPoints;
-  delete fITSTrackPoints;
-  delete fClusterMap;
-  
-  fPids = 0x0;
-  fPidProb = 0x0;
-  fTPCTrackPoints = 0x0;
-  fITSTrackPoints = 0x0;
-  fClusterMap = 0x0;
-}
-//______________________________________________________________________________
-
-AliAODParticle& AliAODParticle::operator=(const AliAODParticle& in)
-{
-//assigment operator
-//  Info("operator=(const AliAODParticle& in)","AliAODParticle");
-  if (&in != this) {
-    AliVAODParticle::operator=(in);
-    fNPids = in.fNPids;
-    delete [] fPids;
-    delete [] fPidProb;
-    fPids = new Int_t[fNPids];
-    fPidProb = new Float_t[fNPids];
-    for (Int_t i = 0; i < fNPids;i++)
-      {
-       fPids[i]    = in.fPids[i];
-       fPidProb[i] = in.fPidProb[i];
-      }
-    
-    fPdgIdx = in.fPdgIdx; 
-    fIdxInEvent = in.fIdxInEvent;  
-    fCalcMass = in.GetCalcMass();
-    fPx = in.Px();
-    fPy = in.Py();
-    fPz = in.Pz();
-    fE = in.E(); 
-    fVx = in.Vx();
-    fVy = in.Vy();
-    fVz = in.Vz();
-    fVt = in.T();
-    
-    delete fTPCTrackPoints;
-    fTPCTrackPoints = (in.fTPCTrackPoints)?(AliTrackPoints*)in.fTPCTrackPoints->Clone():0x0;
-    
-    delete fITSTrackPoints;
-    fITSTrackPoints = (in.fITSTrackPoints)?(AliTrackPoints*)in.fITSTrackPoints->Clone():0x0;
-    
-    delete fClusterMap;
-    fClusterMap =  (in.fClusterMap)?(AliClusterMap*)in.fClusterMap->Clone():0x0;
-  }
-  return *this;
-}
-//______________________________________________________________________________
-
-void AliAODParticle::SetPdgCode(Int_t pdg,Float_t prob)
-{
-//Set PDG Code
-  SetPIDprobability(pdg,prob);
-  fPdgIdx = GetPidSlot(pdg);
-}
-
-//______________________________________________________________________________
-void AliAODParticle::SetPIDprobability(Int_t pdg, Float_t prob)
-{
-//Sets another pdg code and corresponding probabilty
-//Ids are set in decreasing order
-//Check if total probability is not overcoming unity is performed
-//in case, warning is printed
-  AliDebug(9,Form("SetPIDprobability","Setting PID %d prob %f",pdg,prob));
-
-  Float_t totprob = 0.0;//sums up probabilities
-  Int_t idx = GetPidSlot(pdg);
-  Int_t i;
-
-  if (idx > -1) 
-   {
-     fPidProb[idx] = prob;
-     for (i = 0; i < fNPids;i++) totprob+=fPidProb[i];
-     if (totprob > (1.0+0.000001))
-       {
-         Warning("SetPIDprobability","Total probability greater than unity (%f)",totprob);
-       }
-     AliDebug(9,Form("Current Total probability: %f",totprob));
-     return;
-   }
-    
-  Int_t currentpid = GetPdgCode();
-  fNPids++;
-  Float_t* aPidProbNew = new Float_t[fNPids];
-  Int_t* aPidsNew = new Int_t[fNPids];
-  
-  for (i = 0; i < fNPids-1;i++)//find a slot
-   {
-     if ( fPidProb[i] > prob)
-      {
-        AliDebug(9,Form("Copying entry %d",i));
-        aPidProbNew[i] = fPidProb[i];
-        aPidsNew[i] = fPids[i];
-        totprob+=fPidProb[i];
-      }
-     else break;
-   }
-
-  AliDebug(9,Form("SetPID","Setting new PID on entry %d",i));
-  aPidProbNew[i] = prob;
-  aPidsNew[i] = pdg;
-  totprob+=prob;
-  
-
-  for (Int_t j = fNPids-1; j > i ;j--)//copy rest of old arays 
-   {
-     AliDebug(9,Form("SetPID","Copying from old entry %d to new entry %d",j-1,j));
-     aPidProbNew[j] = fPidProb[j-1];
-     aPidsNew[j] = fPids[j-1];
-     totprob+=fPidProb[j-1];
-   }
-
-  delete [] fPidProb;
-  delete [] fPids;
-  
-  fPidProb = aPidProbNew;
-  fPids = aPidsNew;
-  
-  fPdgIdx = GetPidSlot(currentpid);
-  if (fPdgIdx == -1) fPdgIdx = 0;
-  
-  if (totprob > (1.0+0.000001))//space for numerical error
-   {
-     Warning("SetId","Total probability is greater than unity (%f)!!!",totprob);
-     Print();
-   }
-}
-//______________________________________________________________________________
-
-Float_t AliAODParticle::GetPIDprobability(Int_t pdg) const
-{
-//Returns probability that this particle is the type of pdg
-  Int_t idx = GetPidSlot(pdg);
-  if (idx < 0) return 0.0;//such pid was not specified for this particle
-  return fPidProb[idx];
-}
-//______________________________________________________________________________
-
-const Char_t* AliAODParticle::GetName() const 
-{
-  //returns name of this particle 
-   static char def[4] = "XXX";
-   const TParticlePDG *ap = TDatabasePDG::Instance()->GetParticle(GetPdgCode());
-   if (ap) return ap->GetName();
-   else    return def;
-}
-//______________________________________________________________________________
-
-Int_t AliAODParticle::GetPidSlot(Int_t pdg) const
-{
- //returns position of the given PID in fPids (and fPidProb) array.
- if (fPids == 0x0) return -1;
- for (Int_t i = 0; i< fNPids; i++)
-  {
-   if (fPids[i] == pdg) return i;
-  }
- return -1;
-}
-//______________________________________________________________________________
-
-Int_t AliAODParticle::GetNthPid(Int_t idx) const
-{
-  //returns PID sitting on slot idx in fPids
-  if ( (idx < 0) || (idx >= fNPids) )
-   {
-     Error("GetNthPid","Out Of Bounds");
-     return 0;
-   }
-  return fPids[idx];
-}
-//______________________________________________________________________________
-
-Float_t AliAODParticle::GetNthPidProb(Int_t idx) const
-{
-  //returns PID sitting on slot idx in fPidProb
-  if ( (idx < 0) || (idx >= fNPids) )
-   {
-     Error("GetNthPid","Out Of Bounds");
-     return 0;
-   }
-  return fPidProb[idx];
-}
-//______________________________________________________________________________
-
-void AliAODParticle::Print(const Option_t * /*opt*/) const
-{
-//prints information about particle
-  printf("____________________________________________________\n");
-  printf("Idx: %d  PID: %d  Name: ",fIdxInEvent,GetPdgCode());
-  TParticlePDG *pdgp = TDatabasePDG::Instance()->GetParticle(GetPdgCode());
-  if (pdgp)
-   {
-     printf("%s Mass: %f\n",pdgp->GetName(),pdgp->Mass());
-   }
-  else
-   {
-     printf("Not known\n");
-   }
-  
-  printf("Px: %+f Py: %+f Pz: %+f E: %+f Calculated Mass: %f\nVx: %+f Vy: %+f Vz: %+f T: %+f\n",
-          Px(),Py(),Pz(),E(),GetCalcMass(),Vx(),Vy(),Vz(),T());
-
-  for (Int_t i = 0; i < fNPids; i++)
-   {
-     printf("# %d  PID: %d  Probability %f name ",i,fPids[i],fPidProb[i]);
-     const TParticlePDG *ap = TDatabasePDG::Instance()->GetParticle(fPids[i]);
-     if (ap)
-      {
-        printf("%s Mass %f\n",ap->GetName(),ap->Mass());
-      }
-     else
-      {
-        printf("Not known\n");
-      }
-   }
-  
-  if (fITSTrackPoints) fITSTrackPoints->Print();
-  if (fTPCTrackPoints) fTPCTrackPoints->Print();
-   
-}
-
-//______________________________________________________________________________
-
-//void AliAODParticle::Streamer(TBuffer &b)
-//{
-//     // Stream all objects in the array to or from the I/O buffer.
-//   UInt_t R__s, R__c;
-//   Int_t i;
-//   if (b.IsReading()) 
-//    {
-//      delete [] fPids;
-//      delete [] fPidProb;
-//      
-//      Version_t v = b.ReadVersion(&R__s, &R__c);
-//      if (v == 1)
-//       {
-//         AliAODParticle::Class()->ReadBuffer(b, this);
-//      }
-//      else
-//       {
-//        TObject::Streamer(b);
-//       b >> fPdgIdx;
-//       b >> fIdxInEvent;
-//       
-//       b >> fNPids;
-//       Int_t* fPids = new Int_t[fNPids];
-//        Float_t* fPidProb = new Float_t[fNPids];
-//        for (i = 0;i<fNPids;i++) 
-//         {
-//           b >> fPids[i];
-//         }
-//        for (i = 0;i<fNPids;i++) 
-//        {
-//          b >> fPidProb[i];
-//         }
-//        b >> fCalcMass;
-//
-//        b >> fPx;
-//       b >> fPy;
-//       b >> fPz;
-//        b >> fE;
-//
-//       b >> fVx;
-//        b >> fVy;
-//        b >> fVz;
-//       b >> fVt;
-//       Info("Streamer","Read data");
-//        Print();
-//       }
-//
-//      b.CheckByteCount(R__s, R__c,AliAODParticle::IsA());
-//    } 
-//  else 
-//   {
-//     R__c = b.WriteVersion(AliAODParticle::IsA(), kTRUE);
-//     TObject::Streamer(b);
-//     Info("Streamer","Read data");
-//     Print();
-//
-//     b << fPdgIdx;
-//     b << fIdxInEvent;
-//     b << fNPids;
-//     for (i = 0;i<fNPids;i++) 
-//      {
-//        b << fPids[i];
-//      }
-//      {
-//      {
-//     for (i = 0;i<fNPids;i++) 
-//     {
-//        b << fPidProb[i];
-//      }
-//     b << fCalcMass;
-//
-//     b << fPx;
-//     b << fPy;
-//     b << fPz;
-//     b << fE;
-//
-//     b << fVx;
-//     b << fVy;
-//     b << fVz;
-//     b << fVt;
-//
-//    b.SetByteCount(R__c, kTRUE);
-//   }
-//}
diff --git a/ANALYSIS/AliAODParticle.h b/ANALYSIS/AliAODParticle.h
deleted file mode 100644 (file)
index 911562f..0000000
+++ /dev/null
@@ -1,165 +0,0 @@
-#ifndef ALIAODPARTICLE_H
-#define ALIAODPARTICLE_H
-//___________________________________________________________
-/////////////////////////////////////////////////////////////
-//
-// class AliAODParticle
-//
-// Ali HBT Particle: simplified class TParticle
-// Simplified in order to minimize the size of the object
-//  - we want to keep a lot of such a objects in memory
-// Additionaly adjusted for HBT Analysies purposes
-// + pointer to Track Points
-// + pointer to Cluster Map(s)
-//
-// Piotr.Skowronski@cern.ch
-//
-/////////////////////////////////////////////////////////////
-
-#include "AliVAODParticle.h"
-#include <TLorentzVector.h>
-#include <TMath.h>
-#include <TDatabasePDG.h>
-
-
-class TParticle;
-class AliTrackPoints;
-class AliClusterMap;
-
-class AliAODParticle: public AliVAODParticle
-{
-public:
-                                // ****** constructors and destructor
-  AliAODParticle();
-  AliAODParticle(const AliAODParticle& in); 
-  AliAODParticle(const AliVAODParticle& in); 
-  AliAODParticle(Int_t pdg, Int_t idx, Double_t px, Double_t py, Double_t pz, Double_t etot,
-                 Double_t vx, Double_t vy, Double_t vz, Double_t time);
-
-  AliAODParticle(Int_t pdg, Float_t prob, Int_t idx, Double_t px, Double_t py, Double_t pz, Double_t etot,
-                 Double_t vx, Double_t vy, Double_t vz, Double_t time);
-
-  AliAODParticle(const TParticle& p, Int_t idx);
-
-  virtual ~AliAODParticle();
-  
-  AliAODParticle& operator=(const AliAODParticle& in); 
-  
-  void           Clear(Option_t* /*option*/ ="");//Must be implemented in order to store this object in Clones Array
-  
-  void           SetPIDprobability(Int_t pdg, Float_t prob = 1.0);
-  Float_t        GetPIDprobability(Int_t pdg) const;
-  Double_t       GetProbability(Int_t pdg) const {return GetPIDprobability(pdg);}
-  
-  Int_t          GetMostProbable() const { return (fPids)?fPids[0]:0;}
-  
-  Int_t          GetPdgCode      () const { return (fPids)?fPids[fPdgIdx]:0;}
-
-  Double_t       GetPidProb      () const { return (fPidProb)?fPidProb[fPdgIdx]:0;}
-  
-  Int_t          GetUID          () const { return fIdxInEvent;}
-  Int_t          GetNumberOfPids () const { return fNPids;}
-  Int_t          GetNthPid         (Int_t idx) const;
-  Float_t        GetNthPidProb     (Int_t idx) const;
-      
-  void           SetPdgCode(Int_t pdg, Float_t prob = 1.0);
-  Double_t       GetCalcMass     () const { return fCalcMass; }
-  Double_t       Mass            () const { return (GetPDG())?GetPDG()->Mass():-1.;}
-  
-  
-  TParticlePDG*  GetPDG          () const {return TDatabasePDG::Instance()->GetParticle(GetPdgCode());}
-  Double_t       Charge          () const { return (GetPDG())?GetPDG()->Charge():1.e8;}
-  
-  Int_t          Beauty          ()  { return GetPDG()->Beauty(); }
-  Int_t          Charm           ()  { return GetPDG()->Charm(); }
-  Int_t          Strangeness     ()  { return GetPDG()->Strangeness();}
-  void ProductionVertex(TLorentzVector &v) const { v.SetXYZT(fVx,fVy,fVz,fVt);}
-
-
-  Double_t         Vx    () const { return fVx;}
-  Double_t         Vy    () const { return fVy;}
-  Double_t         Vz    () const { return fVz;}
-  Double_t         T     () const { return fVt;}
-
-  Double_t         Px    () const { return fPx; } //X coordinate of the momentum
-  Double_t         Py    () const { return fPy; } //Y coordinate of the momentum
-  Double_t         Pz    () const { return fPz; } //Z coordinate of the momentum
-  Double_t         P     () const                 //momentum
-    { return TMath::Sqrt(fPx*fPx+fPy*fPy+fPz*fPz); }
-  
-  void Momentum(TLorentzVector &v) const { v.SetPxPyPzE(fPx,fPy,fPz,fE);}
-    
-  Double_t         Pt    () const  //transverse momentum
-    { return TMath::Sqrt(fPx*fPx+fPy*fPy); }
-  Double_t         E() const { return fE; }
-  
-                                   //Pseudo Rapidity
-  Double_t         Eta   () const { if (P() != fPz) return 0.5*TMath::Log((P()+fPz)/(P()-fPz)); 
-                                    else return 1.e30;}
-
-                                   //Rapidity
-  Double_t         Y     () const { if (fE  != fPz) return 0.5*TMath::Log((fE+fPz)/(fE-fPz));
-                                    else return 1.e30;}
-
-  Double_t         Phi   () const { return TMath::Pi()+TMath::ATan2(-fPy,-fPx); }
-
-  Double_t         Theta () const { return (fPz==0)?TMath::PiOver2():TMath::ACos(fPz/P()); }
-
-  // setters
-
-  void           SetMomentum(Double_t px, Double_t py, Double_t pz, Double_t e)
-                             {fPx=px; fPy=py; fPz=pz; fE=e;}
-  void           SetMomentum(const TLorentzVector& p)
-                             {SetMomentum(p.Px(),p.Py(),p.Pz(),p.Energy());}
-
-  void           SetProductionVertex(Double_t vx, Double_t vy, Double_t vz, Double_t t)
-                             {fVx=vx; fVy=vy; fVz=vz; fVt=t;}
-  void           SetProductionVertex(const TLorentzVector& v)
-                             {SetProductionVertex(v.X(),v.Y(),v.Z(),v.T());}
-  void           SetCalcMass(Double_t mass) {fCalcMass = mass;}
-  
-  void            SetUID(Int_t id){fIdxInEvent = id;}
-  
-  const Char_t*   GetName() const; 
-  void            Print(const Option_t * opt = "") const;
-  
-  void            SetTPCTrackPoints(AliTrackPoints* tpts){fTPCTrackPoints = tpts;}
-  AliTrackPoints* GetTPCTrackPoints() const {return fTPCTrackPoints;}
-  void            SetITSTrackPoints(AliTrackPoints* tpts){fITSTrackPoints = tpts;}
-  AliTrackPoints* GetITSTrackPoints() const {return fITSTrackPoints;}
-  void            SetClusterMap(AliClusterMap* cm){fClusterMap = cm;}
-  AliClusterMap*  GetClusterMap() const {return fClusterMap;}
-  
-  
-protected:
-  Int_t          GetPidSlot(Int_t pdg) const;//returns position of the given PID in fPids (and fPidProb) array.
-
-private:
-  Int_t          fPdgIdx;               // index of PDG code of the particle in fPids
-  Int_t          fIdxInEvent;           // index of a particle: the same particle can appear in the event
-                                        //  many times with different pid's. Idx allows to check that they are the same particles
-  Int_t          fNPids;                // number of non-zero proboble Pids
-  Int_t         *fPids;                 // [fNPids] Array with PIDs
-  Float_t       *fPidProb;              // [fNPids] PIDs probabilities
-  Double_t       fCalcMass;             // Calculated mass
-
-  
-  Double_t       fPx;                   // x component of momentum
-  Double_t       fPy;                   // y component of momentum
-  Double_t       fPz;                   // z component of momentum
-  Double_t       fE;                    // Energy
-
-  Double_t       fVx;                   // x of production vertex
-  Double_t       fVy;                   // y of production vertex
-  Double_t       fVz;                   // z of production vertex
-  Double_t       fVt;                   // t of production vertex
-
-  AliTrackPoints* fTPCTrackPoints;      // track positions along trajectory - used by anti-merging cut
-  AliTrackPoints* fITSTrackPoints;      // track positions along trajectory - used by anti-merging cut
-  AliClusterMap*  fClusterMap;       // bit map of cluters occupation; 1 if has cluter on given layer/padrow/...
-    
-  ClassDef(AliAODParticle,3)  // TParticle vertex particle information
-};
-
-#endif
diff --git a/ANALYSIS/AliAODParticleBaseCut.cxx b/ANALYSIS/AliAODParticleBaseCut.cxx
deleted file mode 100644 (file)
index 2267798..0000000
+++ /dev/null
@@ -1,192 +0,0 @@
-#include "AliAODParticleBaseCut.h"
-//__________________________________________________________________________
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// class AliAODParticleBaseCut                                            //
-//                                                                        //
-// Set of classes for performing cuts on particle properties of           //
-// AliAODParticleBaseCut is a base class for "base                        //
-// particle cuts". Further, there are implemented classes that performs   //
-// cuts on the most common particle properties like pt, pseudo rapidity,  //
-// angles, anergy, etc.                                                   //
-//                                                                        //
-// There are also implemeted base cuts that perform logical operations    //
-// on results of base particle cuts: AliAODOrCut and  AliAODAndCut.       //
-//                                                                        //
-// Each base cut has a property, thet allows to distinguish them.         //
-// This functionality is used by the interface methods of Particle Cut    //
-// that allows easy update ranges.                                        //
-//                                                                        //
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html    //
-// responsible: Piotr Skowronski@cern.ch                                  //
-//                                                                        //
-////////////////////////////////////////////////////////////////////////////
-
-
-#include <Riostream.h>
-
-ClassImp(AliAODParticleBaseCut)
-  void AliAODParticleBaseCut::Print(const Option_t * /*opt*/) const
-{
-  // prints the information anout the base cut to stdout
-  cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
-  PrintProperty();
-}
-/******************************************************************/
-
-void AliAODParticleBaseCut::PrintProperty(void) const
-{
- //prints the property name 
- switch (fProperty)
-  {
-   case  kAODP: 
-     cout<<"kAODP"; break;
-   case  kAODPt: 
-     cout<<"kAODPt"; break;
-   case  kAODE: 
-     cout<<"kAODE"; break;
-   case  kAODRapidity: 
-     cout<<"kAODRapidity"; break;
-   case  kAODPseudoRapidity: 
-     cout<<"kAODPseudoRapidity"; break;
-   case  kAODPx: 
-     cout<<"kAODPx"; break;
-   case  kAODPy: 
-     cout<<"kAODPy"; break;
-   case  kAODPz: 
-     cout<<"kAODPz"; break;   
-   case  kAODPhi: 
-     cout<<"kAODPhi"; break;
-   case  kAODTheta: 
-     cout<<"kAODTheta"; break;
-   case  kAODVx: 
-     cout<<"kAODVx"; break;
-   case  kAODVy: 
-     cout<<"kAODVy"; break;
-   case  kAODVz: 
-     cout<<"kAODVz"; break;
-   case  kAODPid: 
-     cout<<"kAODPid"; break;
-   case  kAODNone: 
-     cout<<"kAODNone"; break;
-   default: 
-     cout<<"Property Not Found";
-  }
- cout<<endl;
-}
-ClassImp( AliAODMomentumCut )
-
-ClassImp( AliAODPtCut )
-ClassImp( AliAODEnergyCut )
-ClassImp( AliAODRapidityCut )
-ClassImp( AliAODPseudoRapidityCut )
-ClassImp( AliAODPxCut )
-ClassImp( AliAODPyCut )
-ClassImp( AliAODPzCut )
-ClassImp( AliAODPhiCut )
-ClassImp( AliAODThetaCut )
-ClassImp( AliAODVxCut )
-ClassImp( AliAODVyCut )
-ClassImp( AliAODVzCut )
-
-ClassImp( AliAODPIDCut )
-
-void AliAODPIDCut::Print(const Option_t * /*opt*/) const
-{
-  cout<<"PID "<<fPID<<" ";
-  AliAODParticleBaseCut::Print();
-}
-
-ClassImp( AliAODLogicalOperCut )
-
-AliAODLogicalOperCut::AliAODLogicalOperCut():
- AliAODParticleBaseCut(-10e10,10e10,kAODNone),
- fFirst(new AliAODDummyBaseCut),
- fSecond(new AliAODDummyBaseCut)
-{
- //ctor
-}
-/******************************************************************/
-
-AliAODLogicalOperCut::AliAODLogicalOperCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):
- AliAODParticleBaseCut(-10e10,10e10,kAODNone),
- fFirst((first)?(AliAODParticleBaseCut*)first->Clone():0x0),
- fSecond((second)?(AliAODParticleBaseCut*)second->Clone():0x0)
-{
-  //ctor
-  if ( (fFirst && fSecond) == kFALSE) 
-   {
-     Fatal("AliAODLogicalOperCut","One of parameters is NULL!");
-   }
-}
-/******************************************************************/
-
-AliAODLogicalOperCut::~AliAODLogicalOperCut()
-{
-  //destructor
-  delete fFirst;
-  delete fSecond;
-}
-/******************************************************************/
-
-Bool_t AliAODLogicalOperCut::AliAODDummyBaseCut::Rejected(AliVAODParticle* /*part*/)  const
-{
-  //checks if particles passes properties defined by this cut
-  Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
-  return kFALSE;//accept
-}
-/******************************************************************/
-
-void AliAODLogicalOperCut::Streamer(TBuffer &b)
-{
-  // Stream all objects in the array to or from the I/O buffer.
-  UInt_t R__s, R__c;
-  if (b.IsReading()) 
-   {
-     delete fFirst;
-     delete fSecond;
-     fFirst  = 0x0;
-     fSecond = 0x0;
-
-     b.ReadVersion(&R__s, &R__c);
-     TObject::Streamer(b);
-     b >> fFirst;
-     b >> fSecond;
-     b.CheckByteCount(R__s, R__c,AliAODLogicalOperCut::IsA());
-   } 
-  else 
-   {
-     R__c = b.WriteVersion(AliAODLogicalOperCut::IsA(), kTRUE);
-     TObject::Streamer(b);
-     b << fFirst;
-     b << fSecond;
-     b.SetByteCount(R__c, kTRUE);
-  }
-}
-
-/******************************************************************/
-ClassImp(AliAODOrCut)
-
-Bool_t AliAODOrCut::Rejected(AliVAODParticle * p) const
-{
-  //returns true when rejected 
-  //AND operation is a little bit misleading but is correct
-  //User wants to build logical cuts with natural (positive) logic
-  //while AODAN use inernally reverse (returns true when rejected)
-  if (fFirst->Rejected(p) && fSecond->Rejected(p)) return kTRUE;//rejected (both rejected, returned kTRUE)
-  return kFALSE;//accepted, at least one accepted (returned kFALSE)
-}
-/******************************************************************/
-
-ClassImp(AliAODAndCut)
-
-Bool_t AliAODAndCut::Rejected(AliVAODParticle * p)  const
-{
-  //returns true when rejected 
-  //OR operation is a little bit misleading but is correct
-  //User wants to build logical cuts with natural (positive) logic
-  //while AODAN use inernally reverse (returns true when rejected)
-  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
-  return kFALSE;//accepted (both accepted (returned kFALSE))
-}
-/******************************************************************/
diff --git a/ANALYSIS/AliAODParticleBaseCut.h b/ANALYSIS/AliAODParticleBaseCut.h
deleted file mode 100644 (file)
index 22e7bce..0000000
+++ /dev/null
@@ -1,311 +0,0 @@
-#ifndef ALIAODPARTICLEBASECUT_H
-#define ALIAODPARTICLEBASECUT_H
-//__________________________________________________________________________
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// class AliAODParticleBaseCut                                            //
-//                                                                        //
-// Set of classes for performing cuts on particle properties of           //
-// AliAODParticleBaseCut is a base class for "base                        //
-// particle cuts". Further, there are implemented classes that performs   //
-// cuts on the most common particle properties like pt, pseudo rapidity,  //
-// angles, anergy, etc.                                                   //
-//                                                                        //
-// There are also implemeted base cuts that perform logical operations    //
-// on results of base particle cuts: AliAODOrCut and  AliAODAndCut.       //
-//                                                                        //
-// Each base cut has a property, thet allows to distinguish them.         //
-// This functionality is used by the interface methods of Particle Cut    //
-// that allows easy update ranges.                                        //
-//                                                                        //
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html    //
-// responsible: Piotr Skowronski@cern.ch                                  //
-//                                                                        //
-////////////////////////////////////////////////////////////////////////////
-
-
-#include <TObject.h>
-#include "AliVAODParticle.h"
-
-
-class AliAODParticleBaseCut: public TObject
- {
-   //This class defines the range of some property - pure virtual
-   //Property is coded by AliAODCutTypes type
-   
-   public:
-
-     enum EAODCutProperty
-      {
-     //codes of particle properties
-       kAODP,  //Momentum
-       kAODPt, //Transverse momentum
-       kAODE,  //Energy
-       kAODRapidity, //
-       kAODPseudoRapidity,
-       kAODPx, //X coAnddinate of the momentum
-       kAODPy, //Y coAnddinate of the momentum
-       kAODPz, //Z coAnddinate of the momentum
-       kAODPhi,//angle
-       kAODTheta,//angle
-       kAODVx,  // vertex X coAnddinate
-       kAODVy,  // vertex Y coAnddinate
-       kAODVz,  // vertex Z coAnddinate
-       kAODPid, // vertex Z coAnddinate
-     //_____________________________
-       kAODNone
-      };
-
-     
-     AliAODParticleBaseCut(Double_t min = 0.0, Double_t max = 0.0,EAODCutProperty prop = kAODNone):
-                   fProperty(prop),fMin(min),fMax(max){}
-
-     virtual           ~AliAODParticleBaseCut(){}
-     
-     virtual Bool_t    Rejected(AliVAODParticle *p) const;
-     
-     void              SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
-
-     void              SetMinimum(Double_t min){fMin = min;}
-     void              SetMaximum(Double_t max){fMax = max;}
-     
-     Double_t          GetMinimum() const {return fMin;}
-     Double_t          GetMaximum() const {return fMax;}
-     
-     EAODCutProperty   GetProperty() const {return fProperty;}
-     virtual void Print(const Option_t * opt = "") const;
-     
-   protected:
-     virtual Double_t  GetValue(AliVAODParticle *) const = 0;
-
-     EAODCutProperty fProperty; //property that this cut describes
-     Double_t fMin;//minimum value
-     Double_t fMax;//maximum value
-     
-   private:
-     void PrintProperty(void) const;
-     ClassDef(AliAODParticleBaseCut,1)
-   
- };
-
-inline Bool_t
-AliAODParticleBaseCut::Rejected(AliVAODParticle *p) const
-{
-  //cjecks if particle property fits in range
-  if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
-  else return kFALSE; //accepted
-}
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODMomentumCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODP){}
-    virtual ~AliAODMomentumCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->P();}
-    ClassDef(AliAODMomentumCut,1)
- };
-
-class AliAODPtCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODPtCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPt){}
-    virtual ~AliAODPtCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Pt();}
-    ClassDef(AliAODPtCut,1)
- };
-
-
-class AliAODEnergyCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODE){}
-    virtual ~AliAODEnergyCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const {return p->E();}
-    ClassDef(AliAODEnergyCut,1)
- };
-
-class AliAODRapidityCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODRapidity){}
-    virtual ~AliAODRapidityCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Y();}
-    ClassDef(AliAODRapidityCut,1)
- };
-
-class AliAODPseudoRapidityCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPseudoRapidity){}
-    virtual ~AliAODPseudoRapidityCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Eta();}
-    ClassDef(AliAODPseudoRapidityCut,1)
- };
-
-class AliAODPxCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODPxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPx){}
-    virtual ~AliAODPxCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Px();}
-    ClassDef(AliAODPxCut,1)
- };
-
-class AliAODPyCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODPyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPy){}
-    virtual ~AliAODPyCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Py();}
-    ClassDef(AliAODPyCut,1)
- };
-
-
-class AliAODPzCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODPzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPz){}
-    virtual ~AliAODPzCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Pz();}
-    ClassDef(AliAODPzCut,1)
- };
-
-class AliAODPhiCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODPhi){}
-    virtual ~AliAODPhiCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Phi();}
-    ClassDef(AliAODPhiCut,1)
-  
- };
-
-class AliAODThetaCut: public AliAODParticleBaseCut
- {
-  public: 
-    AliAODThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODTheta){}
-    virtual ~AliAODThetaCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Theta();}
-    ClassDef(AliAODThetaCut,1)
-  
- };
-
-class AliAODVxCut: public AliAODParticleBaseCut
- {
- //Cut of the X coAnddinate of the vertex position
-  public: 
-    AliAODVxCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVx){}
-    virtual ~AliAODVxCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Vx();} //retruns value of the vertex
-    ClassDef(AliAODVxCut,1)
-  
- };
-
-
-class AliAODVyCut: public AliAODParticleBaseCut
- {
- //Cut of the X coAnddinate of the vertex position
-  public: 
-    AliAODVyCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVy){}
-    virtual ~AliAODVyCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Vy();} //retruns value of the vertex
-    ClassDef(AliAODVyCut,1)
-  
- };
-
-class AliAODVzCut: public AliAODParticleBaseCut
- {
- //Cut of the X coAnddinate of the vertex position
-  public: 
-    AliAODVzCut(Double_t min = 0.0, Double_t max = 0.0):AliAODParticleBaseCut(min,max,kAODVz){}
-    virtual ~AliAODVzCut(){}
-  protected:
-    Double_t  GetValue(AliVAODParticle * p)const{return p->Vz();} //retruns value of the vertex
-    
-    ClassDef(AliAODVzCut,1)
-  
- };
-
-class AliAODPIDCut:  public AliAODParticleBaseCut
- {
-   public:
-     AliAODPIDCut():AliAODParticleBaseCut(0.0,0.0,kAODPid),fPID(0){}
-     AliAODPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliAODParticleBaseCut(min,max,kAODPid),fPID(pid){}
-     virtual ~AliAODPIDCut(){}
-     
-     void SetPID(Int_t pid){fPID = pid;}
-     void Print(const Option_t * opt = "") const;
-   protected:
-     Double_t  GetValue(AliVAODParticle * p)const{return p->GetProbability(fPID);}
-     Int_t     fPID; //pid of particle that the pid is set 
-     ClassDef(AliAODPIDCut,1)
- };
-//___________________________________________________
-/////////////////////////////////////////////////////
-//                                                 //
-// class AliAODLogicalOperCut                      //
-//                                                 //
-// This cut is base class fAnd class that perfAndms  //
-// logical operations on cuts                      //
-//                                                 //
-/////////////////////////////////////////////////////
-class AliAODLogicalOperCut:  public AliAODParticleBaseCut
- {
-   public:
-     AliAODLogicalOperCut();
-     AliAODLogicalOperCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second);
-     virtual   ~AliAODLogicalOperCut();
-   protected:
-     Double_t  GetValue(AliVAODParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
-     
-     AliAODParticleBaseCut* fFirst;   //second cut
-     AliAODParticleBaseCut* fSecond;  //first cut
-   private:  
-     AliAODLogicalOperCut(const AliAODLogicalOperCut & src);
-     AliAODLogicalOperCut & operator=(const AliAODLogicalOperCut & src);
-    class  AliAODDummyBaseCut: public AliAODParticleBaseCut 
-     {
-       Double_t  GetValue(AliVAODParticle * /*part*/) const {return 0.0;}
-       Bool_t    Rejected(AliVAODParticle* /*part*/) const;
-     };
-     
-    ClassDef(AliAODLogicalOperCut,1)
- };
-
-class AliAODOrCut: public AliAODLogicalOperCut
-{
-   public:
-     AliAODOrCut(){}
-     AliAODOrCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
-     virtual   ~AliAODOrCut(){}
-     Bool_t    Rejected(AliVAODParticle *p) const;
-     ClassDef(AliAODOrCut,1)
-};
-
-class AliAODAndCut: public AliAODLogicalOperCut
-{
-   public:
-     AliAODAndCut(){}
-     AliAODAndCut(AliAODParticleBaseCut* first, AliAODParticleBaseCut* second):AliAODLogicalOperCut(first,second){}
-     virtual   ~AliAODAndCut(){}
-     Bool_t    Rejected(AliVAODParticle *p) const;
-     ClassDef(AliAODAndCut,1)
-};
-
-#endif
diff --git a/ANALYSIS/AliAODParticleCut.cxx b/ANALYSIS/AliAODParticleCut.cxx
deleted file mode 100644 (file)
index 7fbba49..0000000
+++ /dev/null
@@ -1,328 +0,0 @@
-#include "AliAODParticleCut.h"
-//__________________________________________________________________________
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// class AliAODParticleCut                                                //
-//                                                                        //
-// Classes for single particle cuts.                                      //
-// User should use mainly AliAODParticleCut interface methods,            //
-// eventually EmptyCut which passes all particles.                        //
-//                                                                        //
-// There is all interface for setting cuts on all particle properties     //
-// The main method is Rejected - which returns                            //
-//         True to reject particle                                        //
-//         False in case it meets all the criteria of the given cut       //
-//                                                                        //
-// This class has the list of base particle  cuts that perform check on   //
-// single property. Particle  is rejected if any of cuts rejects it.      //
-// There are implemented logical base cuts that perform logical           //
-// operations on results of two other base cuts. Using them user can      //
-// create a tree structure of a base cuts that performs sophisticated     //
-// cut.                                                                   //
-//                                                                        //
-// User can also implement a base cut that performs complicated           //
-// calculations, if it is only more convenient and/or efficint.           //
-//                                                                        //
-// User should delete created cuts  himself                               //
-// because when setting a cut, other objects (functions,analyses,         //
-// readers, other cuts) make their own copy of a cut.                     //
-//                                                                        //
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html    //
-// responsible: Piotr Skowronski@cern.ch                                  //
-//                                                                        //
-////////////////////////////////////////////////////////////////////////////
-
-#include <Riostream.h>
-
-
-ClassImp(AliAODParticleCut)
-const Int_t AliAODParticleCut::fgkMaxCuts = 50;
-/******************************************************************/
-
-AliAODParticleCut::AliAODParticleCut():
- fCuts(new AliAODParticleBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
- fNCuts(0),
- fPID(0)
-{
-  //default ctor
-}
-/******************************************************************/
-
-AliAODParticleCut::AliAODParticleCut(const AliAODParticleCut& in):
-  TObject(in),
-  fCuts(new AliAODParticleBaseCut* [fgkMaxCuts]),//last property in the property
-                                                 //property enum => defines number of properties
-  fNCuts(in.fNCuts),
-  fPID(in.fPID)
-{
-  //cpy ctor
-  for (Int_t i = 0;i<fNCuts;i++)
-   {
-     fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
-   }
-}
-/******************************************************************/
-AliAODParticleCut& AliAODParticleCut::operator=(const AliAODParticleCut& in)
-{
-  //assigment operator
-  Info("operator=","operator=operator=operator=operator=\noperator=operator=operator=operator=");
-  for (Int_t i = 0;i<fNCuts;i++)
-   {
-     delete fCuts[i];
-   }
-
-  fNCuts = in.fNCuts;
-  fPID  = in.fPID;
-  for (Int_t i = 0;i<fNCuts;i++)
-   {
-     fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
-   }
-  return *this;
-}    
-
-/******************************************************************/
-AliAODParticleCut::~AliAODParticleCut()
-{
-  //dtor
-  for (Int_t i = 0;i<fNCuts;i++)
-   {
-     delete fCuts[i];
-   }
-  delete []fCuts;
-} 
-/******************************************************************/
-
-Bool_t AliAODParticleCut::Rejected(AliVAODParticle* p) const
-{
-//method checks all the cuts that are set (in the list)
-//If any of the baseCuts rejects particle False(rejection) is returned
-
- if(!p) 
-  {
-    Warning("Rejected()","No Pasaran! We never accept NULL pointers");
-    return kTRUE;
-  }
- if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
- for (Int_t i = 0;i<fNCuts;i++)
-   {
-    if ( (fCuts[i]->Rejected(p)) )
-     {
-//       fCuts[i]->Print();
-       return kTRUE; //if one of the cuts rejects, then reject
-     }
-   }
-  return kFALSE;
-}
-/******************************************************************/
-
-void AliAODParticleCut::AddBasePartCut(AliAODParticleBaseCut* basecut)
-{
-  //adds the base pair cut (cut on one value)
-   if (!basecut) return;
-   if( fNCuts == (fgkMaxCuts-1) )
-    {
-      Warning("AddBasePartCut","Not enough place for another cut");
-      return;
-    }
-   fCuts[fNCuts++]=basecut;
-}
-
-/******************************************************************/
-AliAODParticleBaseCut* AliAODParticleCut::FindCut(AliAODParticleBaseCut::EAODCutProperty property)
-{
- //returns pointer to the cut checking the given property
- for (Int_t i = 0;i<fNCuts;i++)
-  {
-    if (fCuts[i]->GetProperty() == property) 
-       return fCuts[i]; //we found the cut we were searching for
-  }
- return 0x0; //we did not found this cut
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetMomentumRange(Double_t min, Double_t max)
-{
-  //Sets momentum range
-  AliAODMomentumCut* cut= (AliAODMomentumCut*)FindCut(AliAODParticleBaseCut::kAODP);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODMomentumCut(min,max);
-}
-/******************************************************************/
-
-
-void AliAODParticleCut::SetPtRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODPtCut* cut= (AliAODPtCut*)FindCut(AliAODParticleBaseCut::kAODPt);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODPtCut(min,max);
-
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetEnergyRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODEnergyCut* cut= (AliAODEnergyCut*)FindCut(AliAODParticleBaseCut::kAODE);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODEnergyCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODRapidity);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODRapidityCut(min,max);
-
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPseudoRapidity);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODPseudoRapidityCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPx);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODPxCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
-{  
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPy);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODPyCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPz);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODPzCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPhi);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODPhiCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODTheta);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODThetaCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODVx);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODVxCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODVy);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODVyCut(min,max);
-}
-/******************************************************************/
-
-void AliAODParticleCut::SetVzRange(Double_t min, Double_t max)
-{
-  //name self descriptive
-  AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODVz);
-  if(cut) cut->SetRange(min,max);
-  else fCuts[fNCuts++] = new AliAODVzCut(min,max);
-}
-
-/******************************************************************/
-void AliAODParticleCut::Streamer(TBuffer &b)
-{
-  // Stream all objects in the array to or from the I/O buffer.
-
-   UInt_t R__s, R__c;
-   if (b.IsReading()) 
-    {
-      Int_t i;
-      for (i = 0;i<fNCuts;i++) delete fCuts[i];
-      b.ReadVersion(&R__s, &R__c);
-      TObject::Streamer(b);
-      b >> fPID;
-      b >> fNCuts;
-      for (i = 0;i<fNCuts;i++) 
-       {
-         b >> fCuts[i];
-       }
-       b.CheckByteCount(R__s, R__c,AliAODParticleCut::IsA());
-    } 
-   else 
-    {
-     R__c = b.WriteVersion(AliAODParticleCut::IsA(), kTRUE);
-     TObject::Streamer(b);
-     b << fPID;
-     b << fNCuts;
-     for (Int_t i = 0;i<fNCuts;i++)
-      {
-       b << fCuts[i];
-      }
-     b.SetByteCount(R__c, kTRUE);
-   }
-}
-/******************************************************************/
-
-void AliAODParticleCut::Print(const Option_t * /*opt*/) const
-{
-  //prints all information about the cut to stdout
-  cout<<"Printing AliAODParticleCut, this = "<<this<<endl;
-  cout<<"fPID  "<<fPID<<endl;
-  cout<<"fNCuts  "<<fNCuts <<endl;
-  for (Int_t i = 0;i<fNCuts;i++)
-      {
-       cout<<"  fCuts["<<i<<"]  "<<fCuts[i]<<endl<<"   ";
-       fCuts[i]->Print();
-      }
-}
-
-/******************************************************************/
-/******************************************************************/
-ClassImp(AliAODParticleEmptyCut)
-
-void AliAODParticleEmptyCut::Streamer(TBuffer &b)
- {
-  //stramer
-  AliAODParticleCut::Streamer(b);
- }
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
diff --git a/ANALYSIS/AliAODParticleCut.h b/ANALYSIS/AliAODParticleCut.h
deleted file mode 100644 (file)
index 1a2a530..0000000
+++ /dev/null
@@ -1,126 +0,0 @@
-#ifndef ALIAODPARTICLECUT_H
-#define ALIAODPARTICLECUT_H
-//__________________________________________________________________________
-////////////////////////////////////////////////////////////////////////////
-//                                                                        //
-// class AliAODParticleCut                                                //
-//                                                                        //
-// Classes for single particle cuts.                                      //
-// User should use mainly AliAODParticleCut interface methods,            //
-// eventually EmptyCut which passes all particles.                        //
-//                                                                        //
-// There is all interface for setting cuts on all particle properties     //
-// The main method is Rejected - which returns                            //
-//         True to reject particle                                        //
-//         False in case it meets all the criteria of the given cut       //
-//                                                                        //
-// This class has the list of base particle  cuts that perform check on   //
-// single property. Particle  is rejected if any of cuts rejects it.      //
-// There are implemented logical base cuts that perform logical           //
-// operations on results of two other base cuts. Using them user can      //
-// create a tree structure of a base cuts that performs sophisticated     //
-// cut.                                                                   //
-//                                                                        //
-// User can also implement a base cut that performs complicated           //
-// calculations, if it is only more convenient and/or efficint.           //
-//                                                                        //
-// User should delete created cuts  himself                               //
-// because when setting a cut, other objects (functions,analyses,         //
-// readers, other cuts) make their own copy of a cut.                     //
-//                                                                        //
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html    //
-// responsible: Piotr Skowronski@cern.ch                                  //
-//                                                                        //
-////////////////////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include "AliVAODParticle.h"
-#include "AliAODParticleBaseCut.h"
-
-
-class AliAODParticleEmptyCut;
-class AliAODParticleCut;
-class AliAODParticleBaseCut;
-
-
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODParticleCut: public TObject
-{
-//Class describing cut on particle
-  public:
-
-    AliAODParticleCut();
-    AliAODParticleCut(const AliAODParticleCut& in);
-    virtual ~AliAODParticleCut();
-    AliAODParticleCut& operator = (const AliAODParticleCut& in);
-    
-    virtual Bool_t Rejected(AliVAODParticle* p) const;
-    Bool_t IsEmpty() const {return kFALSE;}
-    
-    void AddBasePartCut(AliAODParticleBaseCut* basecut);
-    
-    Int_t GetPID() const { return fPID;}
-    void SetPID(Int_t pid){fPID=pid;}
-    void SetMomentumRange(Double_t min, Double_t max);
-    void SetPRange(Double_t min, Double_t max){SetMomentumRange(min,max);}
-    void SetPtRange(Double_t min, Double_t max);
-    void SetEnergyRange(Double_t min, Double_t max);
-    void SetRapidityRange(Double_t min, Double_t max);
-    void SetYRange(Double_t min, Double_t max){SetRapidityRange(min,max);}
-    void SetPseudoRapidityRange(Double_t min, Double_t max);
-    void SetPxRange(Double_t min, Double_t max);
-    void SetPyRange(Double_t min, Double_t max);
-    void SetPzRange(Double_t min, Double_t max);
-    void SetPhiRange(Double_t min, Double_t max);
-    void SetThetaRange(Double_t min, Double_t max);
-    void SetVxRange(Double_t min, Double_t max);
-    void SetVyRange(Double_t min, Double_t max);
-    void SetVzRange(Double_t min, Double_t max);
-    
-    void Print(const Option_t * opt = "") const;
-  protected:
-     
-    AliAODParticleBaseCut* FindCut(AliAODParticleBaseCut::EAODCutProperty property);
-
-    AliAODParticleBaseCut ** fCuts;//! Array with cuts
-    Int_t fNCuts; //number of base cuts stored in fCuts
-
-    Int_t fPID; //particle PID  - if=0 (rootino) all pids are accepted
-          
-  private:
-    static const Int_t fgkMaxCuts; //Size of the fCuts array
-
-    ClassDef(AliAODParticleCut,1)
-};
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-class AliAODParticleEmptyCut:  public AliAODParticleCut
-{
-//Empty - it passes possitively all particles - it means returns always False
-//Class describing cut on particles
-  public:
-    AliAODParticleEmptyCut(){};
-    virtual ~AliAODParticleEmptyCut(){};
-    
-    Bool_t Rejected(AliVAODParticle*) const {return kFALSE;} //accept everything
-    Bool_t IsEmpty() const {return kTRUE;}
-
-    ClassDef(AliAODParticleEmptyCut,1)
-};
-
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
-
-
-#endif
diff --git a/ANALYSIS/AliAODRun.cxx b/ANALYSIS/AliAODRun.cxx
deleted file mode 100644 (file)
index d13eb2a..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "AliAODRun.h"
-//____________________
-///////////////////////////////////////////////////////
-//                                                   //
-// AliAODRun                                         //
-//                                                   //
-// Class storing and managing events                 //
-//                                                   //
-// Piotr.Skowronski@cern.ch                          //
-// http://aliweb.cern.ch/people/skowron/analyzer    //
-//                                                   //
-///////////////////////////////////////////////////////
-
-#include <TObjArray.h>
-
-ClassImp(AliAODRun)
-/**************************************************************************/ 
-
-AliAODRun::AliAODRun():
-  fEvents(new TObjArray())
-{ 
- //contructor
-  if(!fEvents) Fatal("AliAODRun::AliAODRun","Can not allocate memory");
-  fEvents->SetOwner(); //array is an owner: when is deleted or cleared it deletes objects that it contains
-}
-/**************************************************************************/
-
-AliAODRun::~AliAODRun()
-{
-  //destructor
-  delete fEvents;//delete array with events
-}
-/**************************************************************************/
-
-void AliAODRun::Reset()
- { 
-   fEvents->Clear();//clear an array with events. 
-                    //All events are deleted because array is an owner (set in constructor)
- }
-/**************************************************************************/
-
-void AliAODRun::AddParticle(Int_t event, AliVAODParticle* part)
-{
- //Adds particle to event
- //if there is no event of this number, crate it and add to the collection
- if(!GetEvent(event))  fEvents->AddAtAndExpand(new AliAOD, event);
- GetEvent(event)->AddParticle(part);
-}
-/**************************************************************************/
-
-void AliAODRun::AddParticle(Int_t event, TParticle* part, Int_t idx)
-{
- //if there is no event of this number, crate it and add to the collection
- if(!GetEvent(event))  fEvents->AddAtAndExpand(new AliAOD, event);
- GetEvent(event)->AddParticle(part,idx);
-}
-/**************************************************************************/
-
-void AliAODRun::AddParticle(Int_t event, Int_t pdg, Int_t idx,
-                            Double_t px, Double_t py, Double_t pz, Double_t etot,
-                            Double_t vx, Double_t vy, Double_t vz, Double_t time)
-{
- //if there is no event of this number, crate it and add to the collection
- if(!GetEvent(event))  fEvents->AddAtAndExpand(new AliAOD, event);
- GetEvent(event)->AddParticle(pdg,idx,px,py,pz,etot,vx,vy,vz,time);
-}
-/**************************************************************************/ 
-
-void AliAODRun::SetEvent(Int_t number, AliAOD* event)
-{
-  //adds an event to the run
-  if (event == 0x0)
-   {
-     delete fEvents->RemoveAt(number);
-     return;
-   }
-  AliAOD* ev = GetEvent(number);
-  if (ev == event) return;
-  
-  delete fEvents->RemoveAt(number);
-  fEvents->AddAtAndExpand(event, number);
-  
-}
-/**************************************************************************/ 
-
diff --git a/ANALYSIS/AliAODRun.h b/ANALYSIS/AliAODRun.h
deleted file mode 100644 (file)
index e3f6dfe..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef ALIAODRUN_H
-#define ALIAODRUN_H
-//____________________
-///////////////////////////////////////////////////////
-//                                                   //
-// AliAODRun                                         //
-//                                                   //
-// Class storing and managing set events             //
-// designed for fast acces                           //
-//                                                   //
-// Piotr.Skowronski@cern.ch                          //
-// http://aliweb.cern.ch/people/skowron/analyzer    //
-//                                                   //
-///////////////////////////////////////////////////////
-
-
-#include "AliAOD.h"
-#include <TObjArray.h>
-
-class AliVAODParticle;
-class TParticle;
-
-class AliAODRun: public TObject
- {
-  public:
-    AliAODRun();
-    virtual ~AliAODRun();
-
-    void            AddParticle(Int_t event, AliVAODParticle* part); //inerface to AliAOD::AddParticle(AliVAODParticle*) 
-    void            AddParticle(Int_t event, TParticle* part, Int_t idx);//inerface to AliAOD::AddParticle(TParticle*) 
-    
-    //inerface to AliAOD::AddParticle(Int_t.Double_t,Double_t,Double_t,Double_t,Double_t,Double_t,Double_t,Double_t,Double_t)
-    void            AddParticle(Int_t event, Int_t pdg, Int_t idx,
-                                Double_t px, Double_t py, Double_t pz, Double_t etot,
-                                Double_t vx, Double_t vy, Double_t vz, Double_t time); 
-    
-    void            SetEvent(Int_t number, AliAOD* event);
-    AliVAODParticle* GetParticle(Int_t event, Int_t n); //returns nth particle from event
-    AliAOD*    GetEvent(Int_t event) const; //returns AliAOD number "event"
-    
-    Int_t           GetNumberOfEvents() const; //returns number of events
-    Int_t              GetNumberOfParticlesInEvent(Int_t event) const; //returns number of particles in event number "event"
-    void            Reset();//clears all events in the array (deletes)
-  protected:
-    TObjArray* fEvents;//!Array containig AliAODs
-  private:
-
-    AliAODRun(const AliAODRun&); // Not implemented    
-    AliAODRun& operator=(const AliAODRun&); // Not implemented    
-
-    ClassDef(AliAODRun,1)
- };
-/**************************************************************************/
-
-inline
-AliAOD* AliAODRun::GetEvent(Int_t event) const
-{
-//returns pointer to AliAOD number "event"
-  //check if array is enough big - protect from error massage from array "Out Of Bounds"
-  if (event>=fEvents->GetSize()) return 0x0;//WARNING, that line relies 
-                                            //on index of first object in TObjArray is 0
-                   //== LowerBound = 0
-  return (AliAOD*)fEvents->At(event);
-}
-/**************************************************************************/
-inline
-AliVAODParticle* AliAODRun::GetParticle(Int_t event, Int_t n) 
-{
- //returns nth particle from event number event
-  AliAOD* e = GetEvent(event);
-  return (e)?e->GetParticle(n):0x0;
-}
-
-/**************************************************************************/
-
-inline
-Int_t AliAODRun::GetNumberOfEvents() const
- {
-//returns number of events in collection
-
-   return fEvents->GetEntriesFast(); //there may be empty slots but we do not care
-                                     //Analysis checks it if return is not NULL
- }
-/**************************************************************************/
-
-inline
-Int_t AliAODRun::GetNumberOfParticlesInEvent(Int_t event) const
-{
-//returns number of Particles in event 
-  AliAOD* e = GetEvent(event);
-  return (e)?e->GetNumberOfParticles():0x0;
-}
-#endif
diff --git a/ANALYSIS/AliAnalysis.cxx b/ANALYSIS/AliAnalysis.cxx
deleted file mode 100644 (file)
index 1536651..0000000
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "AliAnalysis.h"
-//________________________________
-///////////////////////////////////////////////////////////
-//
-// class AliAnalysis
-//
-// Base class for analysis.
-// Each inheriting calss must define 3 methods:
-//   - Init() : that is called before event processing
-//   - ProcessEvent(AliESD*,AliStack*)
-//   - 
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////
-
-#include "AliEventCut.h"
-#include "AliAODPairCut.h"
-
-ClassImp(AliAnalysis)
-
-AliAnalysis::AliAnalysis():
- fEventCut(0x0),
- fCutOnSim(kTRUE),
- fCutOnRec(kTRUE),
- fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
- fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
- fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
- fkPass2(&AliAnalysis::PassPartAndTrack2),
- fkPassPairProp(&AliAnalysis::PassPairPropPartAndTrack)
-{
- //ctor
-}
-/*********************************************************/
-
-AliAnalysis::AliAnalysis(const char* name,const char* title):
- TTask(name,title),
- fEventCut(0x0),
- fCutOnSim(kTRUE),
- fCutOnRec(kTRUE),
- fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
- fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
- fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
- fkPass2(&AliAnalysis::PassPartAndTrack2),
- fkPassPairProp(&AliAnalysis::PassPairPropPartAndTrack)
-{
- //ctor
-}
-/*********************************************************/
-AliAnalysis::AliAnalysis(const AliAnalysis& ana):
- TTask(ana),
- fEventCut(ana.fEventCut),
- fCutOnSim(ana.fCutOnSim),
- fCutOnRec(ana.fCutOnRec),
- fPairCut(ana.fPairCut),
- fkPass(ana.fkPass),
- fkPass1(ana.fkPass1),
- fkPass2(ana.fkPass2),
- fkPassPairProp(ana.fkPassPairProp)
-{
- //ctor
-}
-/*********************************************************/
-
-AliAnalysis::~AliAnalysis()
-{
- //dtor
- delete fEventCut;
-}
-/*********************************************************/
-
-void AliAnalysis::SetEventCut(AliEventCut* evcut)
-{
-//Sets event -  makes a private copy
-  delete fEventCut;
-  if (evcut) fEventCut = (AliEventCut*)evcut->Clone();
-  else fEventCut = 0x0;
-}
-/*********************************************************/
-
-Bool_t AliAnalysis::Rejected(AliAOD* recevent, AliAOD* simevent)
-{
-  //checks the event cut
-  if (fEventCut == 0x0) return kFALSE;
-  
-  if (fCutOnRec)
-    if (fEventCut->Rejected(recevent)) return kTRUE;
-    
-  if (fCutOnSim)
-    if (fEventCut->Rejected(simevent)) return kTRUE;
-  
-  return kFALSE;
-}
-/*************************************************************************************/ 
-
-void AliAnalysis::SetPairCut(AliAODPairCut* cut)
-{
-//Sets new Pair Cut. Old one is deleted
-//Note that it is created new object instead of simple pointer set
-//I do not want to have pointer
-//to object created somewhere else
-//because in that case I could not believe that
-//it would always exist (sb could delete it)
-//so we have always own copy
-
- if(!cut)
-   {
-     Error("AliHBTFunction::SetPairCut","argument is NULL");
-     return;
-   }
- delete fPairCut;
- fPairCut = (AliAODPairCut*)cut->Clone();
-
-}
-/******************************************************************/
-
-void AliAnalysis::SetCutsOnSim()
-{
- // -- aplies only to Process("TracksAndParticles")
- // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
- // Only particles properties are checkes against cuts
-  
-  fCutOnRec = kFALSE;
-  fCutOnSim = kTRUE;
-  
-  fkPass = &AliAnalysis::PassPart;
-  fkPass1 = &AliAnalysis::PassPart1;
-  fkPass2 = &AliAnalysis::PassPart2;
-  fkPassPairProp = &AliAnalysis::PassPairPropPart;
-  
-}
-/*************************************************************************************/ 
-
-void AliAnalysis::SetCutsOnRec()
-{
- // -- aplies only to Process("TracksAndParticles")
- // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
- // Only tracks properties are checkes against cuts
-  
-  fCutOnRec = kTRUE;
-  fCutOnSim = kFALSE;
-  fkPass = &AliAnalysis::PassTrack;
-  fkPass1 = &AliAnalysis::PassTrack1;
-  fkPass2 = &AliAnalysis::PassTrack2;
-  fkPassPairProp = &AliAnalysis::PassPairPropTrack;
-}
-/*************************************************************************************/ 
-
-void AliAnalysis::SetCutsOnRecAndSim()
-{
- // -- aplies only to Process("TracksAndParticles")
- // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
- // Both, tracks and particles, properties are checked against cuts
-
-  fCutOnRec = kTRUE;
-  fCutOnSim = kTRUE;
-
-  fkPass = &AliAnalysis::PassPartAndTrack;
-  fkPass1 = &AliAnalysis::PassPartAndTrack1;
-  fkPass2 = &AliAnalysis::PassPartAndTrack2;
-  fkPassPairProp = &AliAnalysis::PassPairPropPartAndTrack;
-}
diff --git a/ANALYSIS/AliAnalysis.h b/ANALYSIS/AliAnalysis.h
deleted file mode 100644 (file)
index 0d3a10d..0000000
+++ /dev/null
@@ -1,101 +0,0 @@
-#ifndef ALIANALYSIS_H
-#define ALIANALYSIS_H
-//________________________________
-///////////////////////////////////////////////////////////
-//
-// class AliAnalysis
-//
-// Base class for analysis
-//
-//
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////
-
-#include <TTask.h>
-#include <AliAODParticleCut.h>
-#include <AliAODPairCut.h>
-
-class AliAOD;
-class AliStack;
-class AliEventCut;
-class AliVAODParticle;
-class AliAODPair;
-class AliAnalysis: public TTask
-{
-  public: 
-    AliAnalysis();
-    AliAnalysis(const char* name,const char* title);
-    virtual ~AliAnalysis();
-    
-    virtual Int_t Init() = 0;
-    virtual Int_t ProcessEvent(AliAOD* aodrec, AliAOD* aodsim = 0x0) = 0;
-    virtual Int_t Finish() = 0;
-
-    void          SetCutsOnRec();
-    void          SetCutsOnSim();
-    void          SetCutsOnRecAndSim();
-    
-    void          SetEventCut(AliEventCut* evcut);
-    void          SetPairCut(AliAODPairCut* cut);
-    
-  protected:
-    Bool_t        Rejected(AliAOD* recevent, AliAOD* simevent);
-    AliEventCut*  fEventCut;//event cut
-
-    Bool_t        fCutOnSim;//flag indicating that event cut is performed on simulated particles 
-    Bool_t        fCutOnRec;//flag indicating that event cut is performed on reconstructed tracks
-
-    AliAODPairCut*   fPairCut;// Pair cut applied for all mixed particles
-
-    /**********************************************/
-    /*                C U T S                     */
-    /**********************************************/
-
-    Bool_t (AliAnalysis::*fkPass)(AliAODPair* partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
-    Bool_t (AliAnalysis::*fkPass1)(AliVAODParticle* partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on first particle
-    Bool_t (AliAnalysis::*fkPass2)(AliVAODParticle* partpair, AliVAODParticle* trackpair) const;//Pointer to function that performes cut on second particle
-    Bool_t (AliAnalysis::*fkPassPairProp)(AliAODPair* partpair, AliAODPair* trackpair) const;//Pointer to function that performes pair cut
-
-    Bool_t PassPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->Rejected((AliAODPair*)partpair))?kTRUE:fPairCut->Rejected((AliAODPair*)trackpair);}
-    Bool_t PassPartAndTrack1(AliVAODParticle* part, AliVAODParticle* track) const;
-    Bool_t PassPartAndTrack2(AliVAODParticle* part, AliVAODParticle* track) const;
-    Bool_t PassPairPropPartAndTrack (AliAODPair* partpair, AliAODPair* trackpair) const {return (fPairCut->PassPairProp((AliAODPair*)partpair))?kTRUE:fPairCut->PassPairProp((AliAODPair*)trackpair);}
-
-    Bool_t PassPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->Rejected((AliAODPair*)partpair);}
-    Bool_t PassPart1(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetFirstPartCut()->Rejected(part);}
-    Bool_t PassPart2(AliVAODParticle* part, AliVAODParticle* /*track*/) const {return fPairCut->GetSecondPartCut()->Rejected(part);}
-    Bool_t PassPairPropPart (AliAODPair* partpair, AliAODPair* /*trackpair*/) const {return fPairCut->PassPairProp((AliAODPair*)partpair);}
-
-    Bool_t PassTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->Rejected((AliAODPair*)trackpair);}
-    Bool_t PassTrack1(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetFirstPartCut()->Rejected(track);}
-    Bool_t PassTrack2(AliVAODParticle* /*part*/, AliVAODParticle* track) const {return fPairCut->GetSecondPartCut()->Rejected(track);}
-    Bool_t PassPairPropTrack (AliAODPair* /*partpair*/, AliAODPair* trackpair) const {return fPairCut->PassPairProp((AliAODPair*)trackpair);}
-
-    AliAnalysis(const AliAnalysis&); 
-
-  private:
-    AliAnalysis& operator=(const AliAnalysis&); // Not implemented
-
-    ClassDef(AliAnalysis,1)
-};
-
-
-inline Bool_t AliAnalysis::PassPartAndTrack1(AliVAODParticle* part,AliVAODParticle* track) const
-{
-//Checks first particle from both, particle and track pairs
-  AliAODParticleCut* pc = fPairCut->GetFirstPartCut();
-  return (pc->Rejected(part))?kTRUE:pc->Rejected(track);
-}
-/*************************************************************************************/
-
-inline Bool_t AliAnalysis::PassPartAndTrack2(AliVAODParticle* part,AliVAODParticle* track) const
-{
-//Checks second particle from both, particle and track pairs
-  AliAODParticleCut* pc = fPairCut->GetSecondPartCut();
-  return (pc->Rejected(part))?kTRUE:pc->Rejected(track);
-}
-/*************************************************************************************/ 
-
-#endif
diff --git a/ANALYSIS/AliAnalysisEventCuts.cxx b/ANALYSIS/AliAnalysisEventCuts.cxx
deleted file mode 100644 (file)
index de437cf..0000000
+++ /dev/null
@@ -1,314 +0,0 @@
-/**************************************************************************
- * Author: Panos Christakoglou.                                           *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-//-----------------------------------------------------------------
-//           AliAnalysisEventCuts class
-//   This is the class to deal with the event and track level cuts
-//   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
-//-----------------------------------------------------------------
-
-
-
-//ROOT
-#include <TPaveText.h>
-#include <TText.h>
-#include <TLine.h>
-#include <TCanvas.h>
-
-#include "AliLog.h"
-#include "AliESD.h"
-
-#include "AliAnalysisEventCuts.h"
-
-ClassImp(AliAnalysisEventCuts)
-
-//----------------------------------------//
-  AliAnalysisEventCuts::AliAnalysisEventCuts() :
-    TObject(),
-    fVerboseOff(0), fVxMin(0), fVxMax(0),
-    fVyMin(0), fVyMax(0),
-    fVzMin(0), fVzMax(0),
-    fMultMin(0), fMultMax(0),
-    fVzFlagType(""),
-    fMult(0), fVx(0), fVy(0), fVz(0),
-    fVzFlag(0), fTotalEvents(0),
-    fAcceptedEvents(0), fFlagMult(0),
-    fFlagVx(0), fFlagVy(0), fFlagVz(0),
-    fFlagVzType(0) {
-    //Default constructor which calls the Reset method.
-    Reset();
-  }
-
-//----------------------------------------//
-AliAnalysisEventCuts::~AliAnalysisEventCuts()
-{
-  //Defaut destructor.
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::Reset()
-{
-  fVerboseOff = kFALSE;
-
-  //Sets dummy values to every private member.
-  fVxMin = -1000.0;
-  fVxMax = 1000.0; 
-  fVyMin = -1000.0;
-  fVyMax = 1000.0;  
-  fVzMin = -1000.0;
-  fVzMax = 1000.0;
-  fMultMin = 0;
-  fMultMax = 100000;
-  fVzFlagType = "default";
-
-  fMult = 0;  
-  fVx = 0;  
-  fVy = 0; 
-  fVz = 0; 
-  fVzFlag = 0; 
-  fTotalEvents = 0; 
-  fAcceptedEvents = 0; 
-
-  fFlagMult = 0;  
-  fFlagVx = 0;  
-  fFlagVy = 0; 
-  fFlagVz = 0; 
-  fFlagVzType = 0; 
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::SetPrimaryVertexXRange(Float_t r1, Float_t r2)
-{
-  //Sets the primary vertex x range.
-  fVxMin = r1;
-  fVxMax = r2; 
-  fFlagVx = 1;  
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::SetPrimaryVertexYRange(Float_t r1, Float_t r2)
-{
-  //Sets the primary vertex y range.
-  fVyMin = r1;
-  fVyMax = r2; 
-  fFlagVy = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::SetPrimaryVertexZRange(Float_t r1, Float_t r2)
-{
-  //Sets the primary vertex z range.
-  fVzMin = r1;
-  fVzMax = r2; 
-  fFlagVz = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::SetMultiplicityRange(Int_t n1, Int_t n2)
-{
-  //Sets the multiplicity range.
-  fMultMin = n1;
-  fMultMax = n2; 
-  fFlagMult = 1;
-}
-
-
-//----------------------------------------//
-Bool_t AliAnalysisEventCuts::IsAccepted(AliESD *esd)
-{
-  //Returns true if the events is accepted otherwise false.
-  fTotalEvents++;
-  if((esd->GetNumberOfTracks() < fMultMin) || (esd->GetNumberOfTracks() > fMultMax)) {
-    fMult++;
-    if(!fVerboseOff)
-      AliInfo(Form("Event rejected due to multiplicity cut"));
-    return kFALSE;
-  }
-  const AliESDVertex *esdvertex = esd->GetVertex();
-  TString vertexname = esdvertex->GetName();
-  if((esdvertex->GetXv() < fVxMin) || (esdvertex->GetXv() > fVxMax)) {
-    fVx++;
-    if(!fVerboseOff)
-      AliInfo(Form("Event rejected due to Vx cut"));
-    return kFALSE;
-  }
-  if((esdvertex->GetYv() < fVyMin) || (esdvertex->GetYv() > fVyMax)) {
-    fVy++;
-    if(!fVerboseOff)
-      AliInfo(Form("Event rejected due to Vy cut"));
-    return kFALSE;
-  }
- if((esdvertex->GetZv() < fVzMin) || (esdvertex->GetZv() > fVzMax)) {
-   fVz++;
-   if(!fVerboseOff)
-     AliInfo(Form("Event rejected due to Vz cut"));
-   return kFALSE;
- }
- if((fFlagVzType == 1)&&(vertexname == "default")) {
-   fVzFlag++;
-   if(!fVerboseOff)
-     AliInfo(Form("Event rejected due to Vz flag cut"));
-   return kFALSE;
- }
- fAcceptedEvents++;
-
- return kTRUE;
-}
-
-
-//----------------------------------------//
-TPaveText *AliAnalysisEventCuts::GetEventCuts()
-{
-  //Shows a TPaveText with all the event cut stats.
-  TCanvas *ccuts = new TCanvas("ccuts","Event cuts",10,10,400,400);
-  ccuts->SetFillColor(10);
-  ccuts->SetHighLightColor(10);
-
-  TPaveText *pave = new TPaveText(0.01,0.01,0.98,0.98);
-  pave->SetFillColor(5);
-  Char_t cutName[256];
-  TLine *l1 = pave->AddLine(0,0.78,1,0.78);
-  l1->SetLineWidth(2);
-  TLine *l2 = pave->AddLine(0,0.58,1,0.58);
-  l2->SetLineWidth(2);
-  TLine *l3 = pave->AddLine(0,0.38,1,0.38);
-  l3->SetLineWidth(2);
-  TLine *l4 = pave->AddLine(0,0.18,1,0.18);
-  l4->SetLineWidth(2);
-  sprintf(cutName,"Total number of events: %d",fTotalEvents);
-  TText *t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Total number of accepted events: %d",fAcceptedEvents);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Multiplicity range: [%d,%d]",fMultMin,fMultMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Events rejected: %d",fMult);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Vx range: [%f,%f]",fVxMin,fVxMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Events rejected: %d",fVx);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Vy range: [%f,%f]",fVyMin,fVyMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Events rejected: %d",fVy);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Vz range: [%f,%f]",fVzMin,fVzMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Events rejected: %d",fVz);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(4);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  return pave;
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::GetEventStats()
-{
-  //Returns the total event stats.
-  //fTotalEvents is the total number of events.
-  //fAcceptedEvents is the total number of accepted events.  
-  AliInfo(Form("Total number of events: %d",fTotalEvents));
-  AliInfo(Form("Total number of accepted events: %d",fAcceptedEvents)); 
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::GetMultStats()
-{
-  //Gets the multiplicity statistics.
-  //Prints the percentage of events rejected due to this cut. 
-  AliInfo(Form("Multiplicity range: [%d,%d]",fMultMin,fMultMax));
-  AliInfo(Form("Events rejected: %d",fMult));
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::GetVxStats()
-{
-  //Gets the Vx statistics.
-  //Prints the percentage of events rejected due to this cut. 
-  AliInfo(Form("Vx range: [%f,%f]",fVxMin,fVxMax));
-  AliInfo(Form("Events rejected: %d",fVx));
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::GetVyStats()
-{
-  //Gets the Vy statistics.
-  //Prints the percentage of events rejected due to this cut. 
-  AliInfo(Form("Vy range: [%f,%f]",fVyMin,fVyMax));
-  AliInfo(Form("Events rejected: %d",fVy));
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::GetVzStats()
-{
-  //Gets the Vz statistics.
-  //Prints the percentage of events rejected due to this cut. 
-  AliInfo(Form("Vz range: [%f,%f]",fVzMin,fVzMax));
-  AliInfo(Form("Events rejected: %d",fVz));
-  AliInfo(Form("Events rejected (Vz flag): %d",fVzFlag));
-}
-
-//----------------------------------------//
-void AliAnalysisEventCuts::PrintEventCuts()
-{
-  //Prints the event stats.
-  //GetEventCuts()->Draw();  
-
-  AliInfo(Form("**************EVENT CUTS**************"));
-  GetEventStats();
-  if(fFlagMult) GetMultStats();
-  if(fFlagVx) GetVxStats();
-  if(fFlagVy) GetVyStats();
-  if((fFlagVz)||(fFlagVzType)) GetVzStats();
-  AliInfo(Form("**************************************"));
-}
-
-
-     
diff --git a/ANALYSIS/AliAnalysisEventCuts.h b/ANALYSIS/AliAnalysisEventCuts.h
deleted file mode 100644 (file)
index 3641ad8..0000000
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef ALIANALYSISEVENTCUTS_H
-#define ALIANALYSISEVENTCUTS_H
-/*  See cxx source for full Copyright notice */
-
-
-/* $Id$ */
-
-//-------------------------------------------------------------------------
-//                       Class AliAnalysisEventCuts
-//   This is the class for the cuts in event & track level
-//
-//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
-//-------------------------------------------------------------------------
-
-#include <TObject.h>
-
-class TPaveText;
-class AliESD;
-
-class AliAnalysisEventCuts : public TObject
-{
- public:
-  AliAnalysisEventCuts();
-  
-  ~AliAnalysisEventCuts();
-
-  void Reset();
-  
-  void SetPrimaryVertexXRange(Float_t r1, Float_t r2);
-  void SetPrimaryVertexYRange(Float_t r1, Float_t r2);
-  void SetPrimaryVertexZRange(Float_t r1, Float_t r2);
-  void SetPrimaryVertexZFlag() {fVzFlagType = "reconstructed";fFlagVzType = 1;};
-  void SetMultiplicityRange(Int_t n1, Int_t n2);
-  void SetVerboseOff() {fVerboseOff = kTRUE;};
-  Bool_t IsAccepted(AliESD *esd);
-
-  TPaveText *GetEventCuts();
-  void PrintEventCuts(); 
-  void GetEventStats();
-  void GetMultStats();
-  void GetVxStats();
-  void GetVyStats();
-  void GetVzStats();
- private:
-  Bool_t fVerboseOff; //cancel the output
-
-  Float_t fVxMin, fVxMax;  //Definition of the range of the Vx
-  Float_t fVyMin, fVyMax;  //Definition of the range of the Vy
-  Float_t fVzMin, fVzMax;  //Definition of the range of the Vz
-  Int_t fMultMin, fMultMax;  //Definition of the range of the multiplicity
-  TString fVzFlagType; //Flag for the primary vertex(good: "reconstructed" -- fake: "default")
-
-  Int_t fMult;  //Number of events rejected due to multiplicity cut
-  Int_t fVx;  //Number of events rejected due to Vx cut
-  Int_t fVy;  //Number of events rejected due to Vy cut
-  Int_t fVz;  //Number of events rejected due to Vz cut
-  Int_t fVzFlag;  //Number of events rejected due to Vz flag cut
-  Int_t fTotalEvents;  //Total number of events
-  Int_t fAcceptedEvents;  //Total number of events accepted
-
-  Int_t fFlagMult; //Flag that shows if the multiplicity cut was imposed
-  Int_t fFlagVx; //Flag that shows if the Vx cut was imposed
-  Int_t fFlagVy; //Flag that shows if the Vy cut was imposed
-  Int_t fFlagVz; //Flag that shows if the Vz cut was imposed
-  Int_t fFlagVzType; //Flag that shows if the Vz flag cut was imposed
-  ClassDef(AliAnalysisEventCuts, 2)
-} ;
-
-#endif
diff --git a/ANALYSIS/AliAnalysisTrackCuts.cxx b/ANALYSIS/AliAnalysisTrackCuts.cxx
deleted file mode 100644 (file)
index f43f5a2..0000000
+++ /dev/null
@@ -1,564 +0,0 @@
-/**************************************************************************
- * Author: Panos Christakoglou.                                           *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-//-----------------------------------------------------------------
-//           AliAnalysisTrackCuts class
-//   This is the class to deal with the event and track level cuts
-//   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
-//-----------------------------------------------------------------
-
-
-
-//ROOT
-#include <TPaveText.h>
-#include <TText.h>
-#include <TLine.h>
-#include <TCanvas.h>
-#include <TObjArray.h>
-#include <Riostream.h>
-
-#include "AliLog.h"
-
-#include "AliESDtrack.h"
-#include "AliESD.h"
-
-#include "AliAnalysisTrackCuts.h"
-
-ClassImp(AliAnalysisTrackCuts)
-
-//----------------------------------------//
-  AliAnalysisTrackCuts::AliAnalysisTrackCuts() :
-  TObject(),
-  fPMin(0), fPMax(0), fPtMin(0), fPtMax(0),
-  fPxMin(0), fPxMax(0), fPyMin(0), fPyMax(0),
-  fPzMin(0), fPzMax(0), fEtaMin(0), fEtaMax(0),
-  fRapMin(0), fRapMax(0), fBrMin(0), fBrMax(0),
-  fBzMin(0), fBzMax(0),
-  fP(0), fPt(0), fPx(0), fPy(0), fPz(0),
-  fEta(0), fRap(0),
-  fbr(0), fbz(0),
-  fTotalTracks(0), fAcceptedTracks(0),
-  fFlagP(0), fFlagPt(0), fFlagPx(0), fFlagPy(0), fFlagPz(0),
-  fFlagEta(0), fFlagRap(0), fFlagbr(0), fFlagbz(0),
-  fAcceptedParticleList(0) {
-  //Default constructor.
-  //Calls the Reset method.
-  Reset();
-}
-
-//----------------------------------------//
-AliAnalysisTrackCuts::~AliAnalysisTrackCuts()
-{
-  //Destructor.
-  delete fAcceptedParticleList;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::Reset()
-{
-  //Assigns dummy values to every private member.
-  fPxMin = -1000.0;
-  fPxMax = 1000.0; 
-  fPyMin = -1000.0;
-  fPyMax = 1000.0;  
-  fPzMin = -1000.0;
-  fPzMax = 1000.0;
-  fPtMin = 0.0;
-  fPtMax = 1000.0;
-  fPMin = 0.0;
-  fPMax = 1000.0;
-  fBrMin = 0.0;
-  fBrMax = 1000.0;
-  fBzMin = 0.0;
-  fBzMax = 1000.0;
-  fEtaMin = -100.0;
-  fEtaMax = 100.0;
-  fRapMin = -100.0;
-  fRapMax = 100.0;
-  
-  fP = 0;  
-  fPt = 0; 
-  fPx = 0;  
-  fPy = 0; 
-  fPz = 0; 
-  fbr = 0; 
-  fbz = 0; 
-  fEta = 0;  
-  fRap = 0; 
-  fTotalTracks = 0; 
-  fAcceptedTracks = 0; 
-
-  fFlagP = 0;  
-  fFlagPt = 0;  
-  fFlagPx = 0;  
-  fFlagPy = 0;  
-  fFlagPz = 0;  
-  fFlagEta = 0;  
-  fFlagRap = 0;  
-  fFlagbr = 0;  
-  fFlagbz = 0;  
-
-  fAcceptedParticleList = new TObjArray();
-}
-
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetPxRange(Float_t r1, Float_t r2)
-{
-  //Sets the range for the momentum x component. 
-  fPxMin = r1;
-  fPxMax = r2;
-  fFlagPx = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetPyRange(Float_t r1, Float_t r2)
-{
-  //Sets the range for the momentum y component. 
-  fPyMin = r1;
-  fPyMax = r2; 
-  fFlagPy = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetPzRange(Float_t r1, Float_t r2)
-{
-  //Sets the range for the momentum z component. 
-  fPzMin = r1;
-  fPzMax = r2; 
-  fFlagPy = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetPRange(Float_t r1, Float_t r2)
-{
-  //Sets the range for the momentum. 
-  fPMin = r1;
-  fPMax = r2; 
-  fFlagPz = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetPtRange(Float_t r1, Float_t r2)
-{
-  //Sets the range for the teransverse momentum. 
-  fPtMin = r1;
-  fPtMax = r2; 
-  fFlagPt = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetBrRange(Float_t r1, Float_t r2)
-{
-  //Sets the range of the closest approach of the track 
-  //to the primary vertex in the r-phi plane. 
-  fBrMin = r1;
-  fBrMax = r2; 
-  fFlagbr = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetBzRange(Float_t r1, Float_t r2)
-{
-  //Sets the range of the closest approach of the track 
-  //to the primary vertex in the beam axis. 
-  fBzMin = r1;
-  fBzMax = r2; 
-  fFlagbz = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetEtaRange(Float_t r1, Float_t r2)
-{
-  //Sets the range of the pseudo-rapidity. 
-  fEtaMin = r1;
-  fEtaMax = r2; 
-  fFlagEta = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::SetRapRange(Float_t r1, Float_t r2)
-{
-  //Sets the range of the rapidity. 
-  fRapMin = r1;
-  fRapMax = r2; 
-  fFlagRap = 1;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetTrackStats()
-{
-  //Gets the statistics.
-  //fTotalTracks is the total number of tracks.
-  //fAcceptedTracks is the number of accepted tracks after the cuts. 
-  AliInfo(Form("Total number of tracks: %d",fTotalTracks));
-  AliInfo(Form("Total number of accepted tracks: %d",fAcceptedTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetPStats()
-{
-  //Gets the momentum statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-   AliInfo(Form("P range: [%f,%f]",fPMin,fPMax));
-  if(fTotalTracks != 0)
-    AliInfo(Form("Tracks rejected: %f",100.0*fP/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetPtStats()
-{
-  //Gets the transverse momentum statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("Pt range: [%f,%f]",fPtMin,fPtMax));
-  if(fTotalTracks != 0) 
-    AliInfo(Form("Tracks rejected: %f",100.0*fPt/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetPxStats()
-{
-  //Gets the x momentum statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("Px range: [%f,%f]",fPxMin,fPxMax));
-  if(fTotalTracks != 0) 
-    AliInfo(Form("Tracks rejected: %f",100.0*fPx/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetPyStats()
-{
-  //Gets the y momentum statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("Py range: [%f,%f]",fPyMin,fPyMax));
-  if(fTotalTracks != 0) 
-    AliInfo(Form("Tracks rejected: %f",100.0*fPy/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetPzStats()
-{
-  //Gets the z momentum statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("Pz range: [%f,%f]",fPzMin,fPzMax));
-  if(fTotalTracks != 0) 
-    AliInfo(Form("Tracks rejected: %f",100.0*fPz/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetEtaStats()
-{
-  //Gets the pseudo-rapidity statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("eta range: [%f,%f]",fEtaMin,fEtaMax));
-  if(fTotalTracks != 0)
-    AliInfo(Form("Tracks rejected: %f",100.0*fEta/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetRapStats()
-{
-  //Gets the rapidity statistics.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("y range: [%f,%f]",fRapMin,fRapMax));
-  if(fTotalTracks != 0)
-    AliInfo(Form("Tracks rejected: %f",100.0*fRap/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetBrStats()
-{
-  //Gets the statistics fro the closest distance of 
-  //the track to the primary vertex in the r-phi plane.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("br range: [%f,%f]",fBrMin,fBrMax));
-  if(fTotalTracks != 0) 
-    AliInfo(Form("Tracks rejected: %f",100.0*fbr/fTotalTracks)); 
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::GetBzStats()
-{
-  //Gets the statistics fro the closest distance of 
-  //the track to the primary vertex in the beam axis.
-  //Prints the percentage of tracks rejected due to this cut. 
-  AliInfo(Form("bz range: [%f,%f]",fBzMin,fBzMax));
-  if(fTotalTracks != 0)
-    AliInfo(Form("Tracks rejected: %f",100.0*fbz/fTotalTracks)); 
-}
-
-
-//----------------------------------------//
-Bool_t AliAnalysisTrackCuts::IsAccepted(AliESD *esd ,AliESDtrack *esdtrack)
-{
-  //Returns true if the tracks is accepted otherwise false.
-  fTotalTracks++;
-  
-  //momentum related calculations
-  Double_t p[3];
-  esdtrack->GetPxPyPz(p);
-  Float_t momentum = TMath::Sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
-  Float_t pt = TMath::Sqrt(pow(p[0],2) + pow(p[1],2));
-  Float_t energy = TMath::Sqrt(pow(esdtrack->GetMass(),2) + pow(momentum,2));
-
-  //y-eta related calculations
-  Float_t eta = -100.;
-  Float_t y = -100.;
-  if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
-    eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
-  if((energy != TMath::Abs(p[2]))&&(momentum != 0))
-    y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
-  //impact parameter related calculations
-  Double_t trackPosition[3];
-  esdtrack->GetXYZ(trackPosition);
-  const AliESDVertex * vertexIn = esd->GetVertex();
-  Double_t vertexPosition[3];
-  vertexIn->GetXYZ(vertexPosition);                
-  for (Int_t ii=0; ii<3; ii++) trackPosition[ii] -= vertexPosition[ii];
-                   
-  Float_t br = Float_t(TMath::Sqrt(pow(trackPosition[0],2) + pow(trackPosition[1],2)));
-  Float_t bz = Float_t(TMath::Abs(trackPosition[2]));
-  if((momentum < fPMin) || (momentum > fPMax)) {
-    fP++;
-    return kFALSE;
-  }
-  if((pt < fPtMin) || (pt > fPtMax)) {
-    fPt++;
-    return kFALSE;
-  }
-  if((p[0] < fPxMin) || (p[0] > fPxMax)) {
-    fPx++;
-    return kFALSE;
-  }
-  if((p[1] < fPyMin) || (p[1] > fPyMax)) {
-    fPy++;
-    return kFALSE;
-  }
-  if((p[2] < fPzMin) || (p[2] > fPzMax)) {
-    fPz++;
-    return kFALSE;
-  } 
-  if((br < fBrMin) || (br > fBrMax)) {
-    fbr++;
-    return kFALSE;
-  }
-  if((bz < fBzMin) || (bz > fBzMax)) {
-    fbz++;
-    return kFALSE;
-  }
-  if((eta < fEtaMin) || (eta > fEtaMax)) {
-    fEta++;
-    return kFALSE;
-  }
-  if((y < fRapMin) || (y > fRapMax)) {
-    fRap++;
-    return kFALSE;
-  }
-  
-  fAcceptedTracks++;
-  
-  return kTRUE;
-}
-
-
-//----------------------------------------//
-TObjArray *AliAnalysisTrackCuts::GetAcceptedParticles(AliESD *esd)
-{
-  // Returns a list of all tracks that pass the cuts
-  fAcceptedParticleList->Clear();
-  for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
-    AliESDtrack* track = esd->GetTrack(iTrack);
-
-    if(IsAccepted(esd,track)) fAcceptedParticleList->Add(track);            
-  }
-  
-  return fAcceptedParticleList;
-}
-
-//----------------------------------------//
-TPaveText *AliAnalysisTrackCuts::GetTrackCuts()
-{
-  //Shows a TPaveText with all the track cuts stats.
-  TCanvas *ccuts2 = new TCanvas("ccuts2","Track cuts",410,10,400,400);
-  ccuts2->SetFillColor(10);
-  ccuts2->SetHighLightColor(10);
-
-  TPaveText *pave = new TPaveText(0.01,0.01,0.98,0.98);
-  pave->SetFillColor(3);
-  Char_t cutName[256];
-  TLine *l1 = pave->AddLine(0,0.89,1,0.89);
-  l1->SetLineWidth(2);
-  TLine *l2 = pave->AddLine(0,0.79,1,0.79);
-  l2->SetLineWidth(2);
-  TLine *l3 = pave->AddLine(0,0.69,1,0.69);
-  l3->SetLineWidth(2);
-  TLine *l4 = pave->AddLine(0,0.59,1,0.59);
-  l4->SetLineWidth(2);
-  TLine *l5 = pave->AddLine(0,0.49,1,0.49);
-  l5->SetLineWidth(2);
-  TLine *l6 = pave->AddLine(0,0.39,1,0.39);
-  l6->SetLineWidth(2);
-  TLine *l7 = pave->AddLine(0,0.29,1,0.29);
-  l7->SetLineWidth(2);
-  TLine *l8 = pave->AddLine(0,0.19,1,0.19);
-  l8->SetLineWidth(2);
-  TLine *l9 = pave->AddLine(0,0.09,1,0.09);
-  l9->SetLineWidth(2);
-
-  sprintf(cutName,"Total number of tracks: %d",fTotalTracks);
-  TText *t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Total number of accepted tracks: %d",fAcceptedTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"P range: [%f,%f]",fPMin,fPMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fP/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Pt range: [%f,%f]",fPtMin,fPtMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fPt/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-
-  sprintf(cutName,"Px range: [%f,%f]",fPxMin,fPxMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fPx/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Py range: [%f,%f]",fPyMin,fPyMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fPy/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Pz range: [%f,%f]",fPzMin,fPzMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fPz/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  
-  sprintf(cutName,"br range: [%f,%f]",fBrMin,fBrMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fbr/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"bz range: [%f,%f]",fBzMin,fBzMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fbz/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-
-  sprintf(cutName,"eta range: [%f,%f]",fEtaMin,fEtaMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fEta/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-
-  sprintf(cutName,"y range: [%f,%f]",fRapMin,fRapMax);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-  sprintf(cutName,"Tracks rejected: %f",100.0*fRap/fTotalTracks);
-  t1 = pave->AddText(cutName);
-  t1->SetTextColor(1);
-  t1->SetTextSize(0.04);
-  t1->SetTextAlign(11);
-
-  return pave;
-}
-
-//----------------------------------------//
-void AliAnalysisTrackCuts::PrintTrackCuts()
-{
-  //Prints the track cut stats.
-  //GetTrackCuts()->Draw();
-
-  AliInfo(Form("**************TRACK CUTS**************"));
-  GetTrackStats();
-  if(fFlagP)
-    GetPStats();
-  if(fFlagPt)
-    GetPtStats();
-  if(fFlagPx)
-    GetPxStats();
-  if(fFlagPy)
-    GetPyStats();
-  if(fFlagPz)
-    GetPzStats();
-  if(fFlagEta)
-    GetEtaStats();
-  if(fFlagRap)
-    GetRapStats();
-  if(fFlagbr)
-    GetBrStats();
-  if(fFlagbz)
-    GetBzStats(); 
-  AliInfo(Form("**************************************"));
-}
diff --git a/ANALYSIS/AliAnalysisTrackCuts.h b/ANALYSIS/AliAnalysisTrackCuts.h
deleted file mode 100644 (file)
index 56c4cd5..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef ALIANALYSISTRACKCUTS_H
-#define ALIANALYSISTRACKCUTS_H
-/*  See cxx source for full Copyright notice */
-
-
-/* $Id$ */
-
-//-------------------------------------------------------------------------
-//                       Class AliAnalysisTrackCuts
-//   This is the class for the cuts in event & track level
-//
-//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
-//-------------------------------------------------------------------------
-
-#include <TObject.h>
-
-class AliESD;
-class AliESDtrack;
-
-class TPaveText;
-class TObjArray;
-
-class AliAnalysisTrackCuts : public TObject
-{
- public:
-  AliAnalysisTrackCuts();
-  
-  ~AliAnalysisTrackCuts();
-
-  void Reset();
-  
-  void SetPRange(Float_t r1, Float_t r2);
-  void SetPtRange(Float_t r1, Float_t r2);
-  void SetPxRange(Float_t r1, Float_t r2);
-  void SetPyRange(Float_t r1, Float_t r2);
-  void SetPzRange(Float_t r1, Float_t r2);
-  void SetBrRange(Float_t r1, Float_t r2);
-  void SetBzRange(Float_t r1, Float_t r2);
-  void SetEtaRange(Float_t r1, Float_t r2);
-  void SetRapRange(Float_t r1, Float_t r2);
-
-  Bool_t IsAccepted(AliESD *esd,AliESDtrack *esdtrack);
-  TObjArray *GetAcceptedParticles(AliESD *esd);
-
-  TPaveText *GetTrackCuts();
-  void PrintTrackCuts();
-  void GetTrackStats();
-  void GetPStats();
-  void GetPxStats();
-  void GetPyStats();
-  void GetPzStats();
-  void GetPtStats();
-  void GetEtaStats();
-  void GetRapStats();
-  void GetBrStats();
-  void GetBzStats();
-
- private:
-  Float_t fPMin, fPMax;  //Definition of the range of the P
-  Float_t fPtMin, fPtMax;  //Definition of the range of the Pt
-  Float_t fPxMin, fPxMax;  //Definition of the range of the Px
-  Float_t fPyMin, fPyMax;  //Definition of the range of the Py
-  Float_t fPzMin, fPzMax;  //Definition of the range of the Pz
-  Float_t fEtaMin, fEtaMax;  //Definition of the range of the eta
-  Float_t fRapMin, fRapMax;  //Definition of the range of the y
-  Float_t fBrMin, fBrMax;  //Definition of the range of the br
-  Float_t fBzMin, fBzMax;  //Definition of the range of the bz
-
-  Int_t fP;  //Number of events rejected due to P cut
-  Int_t fPt;  //Number of events rejected due to Pt cut
-  Int_t fPx;  //Number of events rejected due to Px cut
-  Int_t fPy;  //Number of events rejected due to Py cut
-  Int_t fPz;  //Number of events rejected due to Pz cut
-  Int_t fEta;  //Number of events rejected due to eta cut
-  Int_t fRap;  //Number of events rejected due to y cut
-  Int_t fbr;  //Number of events rejected due to br cut
-  Int_t fbz;  //Number of events rejected due to bz cut
-  Int_t fTotalTracks;  //Total number of tracks
-  Int_t fAcceptedTracks;  //Total number of accepted tracks
-   
-  Int_t fFlagP;  //Flag that shows if the P cut was imposed
-  Int_t fFlagPt;  //Flag that shows if the Pt cut was imposed
-  Int_t fFlagPx;  //Flag that shows if the Px cut was imposed
-  Int_t fFlagPy;  //Flag that shows if the Py cut was imposed
-  Int_t fFlagPz;  //Flag that shows if the Pz cut was imposed
-  Int_t fFlagEta;  //Flag that shows if the eta cut was imposed
-  Int_t fFlagRap;  //Flag that shows if the y cut was imposed
-  Int_t fFlagbr;  //Flag that shows if the br cut was imposed
-  Int_t fFlagbz;  //Flag that shows if the bz cut was imposed
-  TObjArray *fAcceptedParticleList; //List of accepted particles after quality cuts  
-
-  AliAnalysisTrackCuts(const AliAnalysisTrackCuts&); // Not implemented
-  AliAnalysisTrackCuts& operator=(const AliAnalysisTrackCuts&); // Not implemented
-  
-  ClassDef(AliAnalysisTrackCuts, 2)
-} ;
-
-#endif
diff --git a/ANALYSIS/AliClusterMap.cxx b/ANALYSIS/AliClusterMap.cxx
deleted file mode 100644 (file)
index 711c1ba..0000000
+++ /dev/null
@@ -1,172 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////
-//
-// class AliClusterMap
-// class that describes cluster occupation at TPC
-// Each padraw has a corresponding bit in fPadRawMap
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////////////////////
-
-#include <TString.h>
-
-#include "AliClusterMap.h"
-#include "AliESDtrack.h"
-#include "AliLog.h"
-#include "AliTPCtrack.h"
-
-const Int_t AliClusterMap::fgkNPadRows = 159;
-
-ClassImp(AliClusterMap)
-
-AliClusterMap::AliClusterMap():
- fPadRawMap(fgkNPadRows)
-{
-//ctor
-
-}
-/***********************************************************************/
-AliClusterMap::AliClusterMap(AliESDtrack* track):
- fPadRawMap( (track)?track->GetTPCClusterMap():fgkNPadRows )
-{
- //ctor
- StdoutToAliDebug(3,Print());
-
-} 
-/***********************************************************************/
-
-AliClusterMap::AliClusterMap(AliTPCtrack* track):
- fPadRawMap(fgkNPadRows)
-{
- //ctor
- AliDebug(10,"#####################################################################"); 
- if (track == 0x0)
-  {
-    Error("AliClusterMap","Pointer to TPC track is NULL");
-    return;
-  }
- Int_t prevrow = -1;
- Int_t i = 0;
- for ( ; i < track->GetNumberOfClusters(); i++)
-  {
-    Int_t idx = track->GetClusterIndex(i);
-    Int_t sect = (idx&0xff000000)>>24;
-    Int_t row = (idx&0x00ff0000)>>16;
-    if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
-    AliDebug(9,Form("Cl.idx is %d, sect %d, row %d",idx,sect,row));
-      
-    fPadRawMap.SetBitNumber(row,kTRUE);
-    
-    //Fill the gap between previous row and this row with 0 bits
-    if (prevrow < 0) 
-     {
-       prevrow = row;//if previous bit was not assigned yet == this is the first one
-     }
-    else
-     { //we don't know the order (inner to outer or reverse)
-       //just to be save in case it is going to change
-       Int_t n = 0, m = 0;
-       if (prevrow < row)
-        {
-          n = prevrow;
-          m = row;
-        }
-       else
-        {
-          n = row;
-          m = prevrow;
-        }
-       for (Int_t j = n+1; j < m; j++)
-        {
-          fPadRawMap.SetBitNumber(j,kFALSE);
-        }
-       prevrow = row; 
-     }
-  }
-  
- StdoutToAliDebug(3,Print());
-
-}
-/***********************************************************************/
-
-void AliClusterMap::Print() const
-{
-//Prints the bit map 
-  TString msg;
-  for ( Int_t i = 0; i < fgkNPadRows; i++)
-   {
-     if ( fPadRawMap.TestBitNumber(i) )
-      {
-        msg+="1";
-      }
-     else
-      {
-        msg+="0";
-      }
-   }
-  Info("AliClusterMap","BitMap is\n  %s",msg.Data());
-  
-}
-
-/***********************************************************************/
-
-Float_t AliClusterMap::GetOverlapFactor(const AliClusterMap& clmap) const
-{
-  //Returns quality factor FQ = Sum(An)/Sum(clusters)
-  //      | -1; if both tracks have a cluster on padrow n
-  //An = <  0; if neither track has a cluster on padrow n
-  //     |  1; if only one trackhas a cluster on padrow n
-  // Returned value ranges between 
-  //  -0.5 (low probability that these tracks are a split track)
-  //  and
-  //   1.0 (high probability that these tracks are a split track)
-  
-  Int_t nh = 0;
-  Int_t an = 0;
-  for ( Int_t i = 0; i < fgkNPadRows; i++)
-   {
-     Bool_t x = HasClAtPadRow(i);
-     Bool_t y = clmap.HasClAtPadRow(i);
-     
-     if (x && y)//both have clasters
-      {
-       an--;
-       nh+=2;
-      }
-     else 
-      {
-       
-       if (x || y)//only one have cluters
-        {
-          an++;
-          nh++;
-        }
-      }
-   }
-  
-  
-  Float_t retval = 0.0;
-  if (nh > 0) retval = ((Float_t)an)/((Float_t)nh);
-  else Warning("GetOverlapFactor","Number of counted cluters is 0.");
-  
-  return retval;
-}
diff --git a/ANALYSIS/AliClusterMap.h b/ANALYSIS/AliClusterMap.h
deleted file mode 100644 (file)
index e382b46..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef ALICLUSTERMAP_H
-#define ALICLUSTERMAP_H
-
-///////////////////////////////////////////////////////////////////////////
-//
-// class AliClusterMap
-// class that describes cluster occupation at TPC
-// Each padraw has a corresponding bit in fPadRawMap
-// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////////////////////
-
-
-#include <TObject.h>
-#include <TBits.h>
-
-class AliTPCtrack;
-class AliESDtrack;
-class TBits;
-
-class AliClusterMap: public TObject
-{
-  public:
-   AliClusterMap();
-   AliClusterMap(AliTPCtrack* track);
-   AliClusterMap(AliESDtrack* track);
-   virtual ~AliClusterMap(){}
-   Float_t GetOverlapFactor(const AliClusterMap& clmap) const;
-   Bool_t  HasClAtPadRow(Int_t i) const { return fPadRawMap.TestBitNumber(i);}
-   void    Print(const Option_t * opt) const {TObject::Print(opt);}
-   void    Print() const;
-  protected:
-  private:
-   TBits    fPadRawMap;//bit vector of length 150 correspondind to total number of padraws in TPC
-   static const Int_t fgkNPadRows; // Number of pad rows
-   ClassDef(AliClusterMap,1)
-};
-
-#endif 
diff --git a/ANALYSIS/AliEventBaseCut.cxx b/ANALYSIS/AliEventBaseCut.cxx
deleted file mode 100644 (file)
index d0c7068..0000000
+++ /dev/null
@@ -1,94 +0,0 @@
-#include "AliEventBaseCut.h"
-//________________________________
-///////////////////////////////////////////////////////////
-//
-// class AliEventBaseCut
-//
-//
-//
-//
-///////////////////////////////////////////////////////////
-
-#include <AliAOD.h>
-ClassImp(AliEventBaseCut)
-
-AliEventBaseCut::AliEventBaseCut():
- fMin(0.0),
- fMax(0.0),
- fProperty(kNone)
-{
-//ctor  
-}
-/**********************************************************/
-
-AliEventBaseCut::AliEventBaseCut(Double_t min, Double_t max, EEventCutProperty prop):
- fMin(min),
- fMax(max),
- fProperty(prop)
-{
- //ctor
-}
-/**********************************************************/
-
-Bool_t AliEventBaseCut::Rejected(AliAOD* aod) const
-{
-//Checks if value is in the range,
-// returns true if it is in the range, false otherwise
-  Double_t v = GetValue(aod);
-//  Info("Rejected","Value %f Min %f Max %f",v,fMin,fMax);
-  if ( ( v < fMin) || ( v > fMax) ) return kTRUE;
-  return kFALSE;
-}
-/**********************************************************/
-/**********************************************************/
-/**********************************************************/
-ClassImp(AliPrimVertexXCut)
-
-Double_t AliPrimVertexXCut::GetValue(AliAOD* aod) const
-{
- //returns x coordinate of the primary vertex
-  Double_t x = 0, y = 0, z = 0;
-  if (aod) aod->GetPrimaryVertex(x,y,z);
-  return x;
-}
-/**********************************************************/
-/**********************************************************/
-/**********************************************************/
-ClassImp(AliPrimVertexYCut)
-
-Double_t AliPrimVertexYCut::GetValue(AliAOD* aod) const
-{
- //returns x coordinate of the primary vertex
-  Double_t x = 0, y = 0, z = 0;
-  if (aod) aod->GetPrimaryVertex(x,y,z);
-  return y;
-}
-/**********************************************************/
-/**********************************************************/
-/**********************************************************/
-ClassImp(AliPrimVertexZCut)
-
-Double_t AliPrimVertexZCut::GetValue(AliAOD* aod) const
-{
- //returns x coordinate of the primary vertex
-  Double_t x = 0, y = 0, z = 0;
-  if (aod) aod->GetPrimaryVertex(x,y,z);
-  return z;
-}
-
-/**********************************************************/
-/**********************************************************/
-/**********************************************************/
-
-ClassImp(AliNChargedCut)
-
-Double_t AliNChargedCut::GetValue(AliAOD* aod) const
-{
-  //returns number of charged particles
-  if (aod) 
-   {
-     return aod->GetNumberOfCharged(fEtaMin,fEtaMax);
-   }  
-  Error("GetValue","Pointer to AOD is NULL");
-  return 0.0;
-}
diff --git a/ANALYSIS/AliEventBaseCut.h b/ANALYSIS/AliEventBaseCut.h
deleted file mode 100644 (file)
index 03c0e2b..0000000
+++ /dev/null
@@ -1,111 +0,0 @@
-#ifndef ALIEVENTBASECUT_H
-#define ALIEVENTBASECUT_H
-//________________________________
-///////////////////////////////////////////////////////////
-//
-// class AliEventBaseCut
-//
-// Base class for cauts that checks only one event property
-//
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////
-
-#include "TObject.h"
-
-class AliAOD;
-
-class AliEventBaseCut: public TObject
-{
-  public: 
-    enum EEventCutProperty {
-       kPrimVertexXCut,kPrimVertexYCut,kPrimVertexZCut,
-       kNChargedCut,kNone
-     };
-
-    AliEventBaseCut();
-    AliEventBaseCut(Double_t min,Double_t max, EEventCutProperty prop = kNone);
-    virtual ~AliEventBaseCut(){}
-    virtual Bool_t Rejected(AliAOD* aod) const;//returns kTRUE if rejected
-    virtual void   SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
-
-    virtual EEventCutProperty GetProperty()const{return fProperty;}
-
-  protected:
-    virtual Double_t GetValue(AliAOD* aod) const = 0;
-    
-    Double_t fMin;//Minimum value
-    Double_t fMax;//Maximum value
-    EEventCutProperty fProperty;//Defines the type of the cut - used by the setters cut
-    
-  private:
-    ClassDef(AliEventBaseCut,1)
-};
-
-/************************************************************/
-
-class AliPrimVertexXCut: public AliEventBaseCut
-{
- public: 
-   AliPrimVertexXCut():AliEventBaseCut(0,0,kPrimVertexXCut){}
-   AliPrimVertexXCut(Double_t min,Double_t max):AliEventBaseCut(min,max,kPrimVertexXCut){}
-   virtual ~AliPrimVertexXCut(){}
- protected:
-   Double_t GetValue(AliAOD* aod) const;
-   
- private:
-   ClassDef(AliPrimVertexXCut,1)
-};
-/************************************************************/
-
-class AliPrimVertexYCut: public AliEventBaseCut
-{
- public: 
-   AliPrimVertexYCut():AliEventBaseCut(0,0,kPrimVertexYCut){}
-   AliPrimVertexYCut(Double_t min,Double_t max):AliEventBaseCut(min,max,kPrimVertexYCut){}
-   virtual ~AliPrimVertexYCut(){}
-   
- protected:
-   Double_t GetValue(AliAOD* aod) const;
-   
- private:
-   ClassDef(AliPrimVertexYCut,1)
-};
-/************************************************************/
-
-class AliPrimVertexZCut: public AliEventBaseCut
-{
- public: 
-   AliPrimVertexZCut():AliEventBaseCut(0,0,kPrimVertexZCut){}
-   AliPrimVertexZCut(Double_t min,Double_t max):AliEventBaseCut(min,max,kPrimVertexZCut){}
-   virtual ~AliPrimVertexZCut(){}
- protected:
-   Double_t GetValue(AliAOD* aod) const;
-   
- private:
-   ClassDef(AliPrimVertexZCut,1)
-};
-
-
-/************************************************************/
-
-class AliNChargedCut: public AliEventBaseCut
-{
- public: 
-   AliNChargedCut():AliEventBaseCut(0,0,kNChargedCut),fEtaMin(-10.0),fEtaMax(10.0){}
-   AliNChargedCut(Int_t min, Int_t max, Double_t etamin = -10.0, Double_t etamax = 10.0):
-       AliEventBaseCut(min,max,kNChargedCut),fEtaMin(etamin),fEtaMax(etamax){}
-   virtual ~AliNChargedCut(){}
-   
-   void     SetEtaRange(Double_t min,Double_t max){fEtaMin = min;fEtaMax = max;}
- protected:
-   Double_t GetValue(AliAOD* aod) const;
-   Double_t fEtaMin;//Defines max of eta range where mult is caclulated
-   Double_t fEtaMax;//Defines min of eta range where mult is caclulated
-   
- private:
-   ClassDef(AliNChargedCut,1)
-};
-
-
-#endif
diff --git a/ANALYSIS/AliEventBuffer.cxx b/ANALYSIS/AliEventBuffer.cxx
deleted file mode 100644 (file)
index 983ef97..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "AliEventBuffer.h"
-
-ClassImp(AliEventBuffer)
-
-//______________________________________________________
-////////////////////////////////////////////////////////
-//
-// class AliEventBuffer
-//
-// FIFO type event buffer
-//
-// Piotr.Skowronski@cern.ch
-//
-////////////////////////////////////////////////////////
-
-AliEventBuffer::AliEventBuffer():
- fSize(-1),fEvents(),fIter(&fEvents)
-{
-  //ctor
-}
-/***********************************************************/
-
-AliEventBuffer::AliEventBuffer(Int_t size):
- fSize(size),fEvents(),fIter(&fEvents)
-{
-  //ctor
-}
-/***********************************************************/
-
-AliEventBuffer::~AliEventBuffer()
-{
-  //dtor -- TList::IsOwner(1) does not work - Valgrind says that there is mem leak
-  //take care owerseves
-  if (fEvents.IsOwner())
-   { 
-     AliAOD* e=0x0;
-     while (( e=RemoveLast() )) delete e;
-   }
-}
-/***********************************************************/
-
-void AliEventBuffer::Reset()
-{
-  //Resets the queue
-  if (fEvents.IsOwner())
-   { 
-     AliAOD* e=0x0;
-     while (( e=RemoveLast() )) delete e;
-   }
-  else
-   {
-     fEvents.RemoveAll();
-   } 
-}
-/***********************************************************/
-
-AliAOD* AliEventBuffer::Push(AliAOD* event)
-{
-  //adds a new event, and returns old of do not fit in size
-  if (fSize == 0) return event;
-  
-  AliAOD* ret = 0x0;
-  
-  if (fSize == fEvents.GetSize()) 
-    ret = dynamic_cast<AliAOD*>(fEvents.Remove(fEvents.Last()));
-  if (event) fEvents.AddFirst(event);
-  return ret;
-}
-
diff --git a/ANALYSIS/AliEventBuffer.h b/ANALYSIS/AliEventBuffer.h
deleted file mode 100644 (file)
index 7b35452..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-#ifndef AliEventBuffer_H
-#define AliEventBuffer_H
-//______________________________________________________
-////////////////////////////////////////////////////////
-//
-// class AliEventBuffer
-//
-// FIFO type event buffer
-//
-// Piotr.Skowronski@cern.ch
-//
-////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include <TList.h>
-#include "AliAOD.h"
-
-class AliEventBuffer: public TObject
-{
-  public:
-    AliEventBuffer();
-    AliEventBuffer(Int_t size);
-    virtual ~AliEventBuffer();
-    
-    AliAOD* Push(AliAOD* event);//adds a new event, and returns old of do not fit in size
-    AliAOD* RemoveLast(){return dynamic_cast<AliAOD*>(fEvents.Remove(fEvents.Last()));}
-    void    ResetIter(){fIter.Reset();}
-    AliAOD* Next(){return dynamic_cast<AliAOD*>( fIter.Next() );}
-    void    SetSize(Int_t size){fSize = size;}
-    Int_t   GetSize() const {return fSize;}
-    void    SetOwner(Bool_t flag) {fEvents.SetOwner(flag);}
-    void    Reset();
-  protected:
-  private:
-    Int_t   fSize;//size of buffer; if -1 infinite size
-    TList   fEvents;//list with arrays
-    TIter   fIter;//iterator
-    ClassDef(AliEventBuffer,1)
-};
-
-
-#endif
diff --git a/ANALYSIS/AliEventCut.cxx b/ANALYSIS/AliEventCut.cxx
deleted file mode 100644 (file)
index 447787c..0000000
+++ /dev/null
@@ -1,139 +0,0 @@
-#include "AliEventCut.h"
-
-///////////////////////////////////////////////////////////
-//
-// class AliEventCut
-//
-// Event cut. It has list of base event cuts. 
-// Each of base event cut checks only one property.
-// Logical base cuts also exists that point to other base cuts.
-// Using them one can build complicated cut with binary tree structure
-// Author: Piotr.Skowronski@cern.ch
-///////////////////////////////////////////////////////////
-
-#include "AliEventBaseCut.h"
-
-ClassImp(AliEventCut)
-
-AliEventCut::AliEventCut():
- fBaseCuts(10)
-{
-//costructor
-
-}
-/*********************************************************/
-AliEventCut::AliEventCut(const AliEventCut& in):
- TObject(in),
- fBaseCuts(in.fBaseCuts)
-{
-  //cpy ctor
-  fBaseCuts.SetOwner(kTRUE);
-}
-/*********************************************************/
-
-AliEventCut::~AliEventCut()
-{
-//costructor
-}
-
-/*********************************************************/
-
-Bool_t AliEventCut::Rejected(AliAOD* aod) const
-{
-  //returns kTRUE if rejected
-  if (aod == 0x0)
-   {
-     Error("Pass","Pointer to AOD is NULL. Not passed the cut");
-     return kFALSE;
-   }
-   
-  TIter iter(&fBaseCuts);
-  AliEventBaseCut* becut;
-  while (( becut = (AliEventBaseCut*)iter() ))
-   {
-     if (becut->Rejected(aod)) return kTRUE;
-   }
-  return kFALSE;
-}
-/*********************************************************/
-void AliEventCut::AddBasePartCut(AliEventBaseCut* ebcut)
-{
-//Adds a base cut
- if (ebcut == 0x0)
-  {
-    Error("AddBasePartCut","Pointer to base cut is NULL");
-    return;
-  }
- if (ebcut->GetProperty() != AliEventBaseCut::kNone)
-  {
-    if (FindCut(ebcut->GetProperty()))
-     {
-       Warning("AddBasePartCut","Cut with this property is already in the list of base cuts");
-     }
-  }  
-  
- fBaseCuts.Add(ebcut->Clone());
-}
-/*********************************************************/
-
-AliEventBaseCut* AliEventCut::FindCut(AliEventBaseCut::EEventCutProperty prop)
-{
-//Finds and returns pointer to the cut with given property
- Int_t n = fBaseCuts.GetEntries();
- for (Int_t i = 0; i<n; i++)
-  {
-    AliEventBaseCut* bcut = (AliEventBaseCut*)fBaseCuts.At(i);
-    if (bcut->GetProperty() == prop)
-       return bcut; //we found the cut we were searching for
-  }
-
- return 0x0; //we did not found this cut
-
-}
-/*********************************************************/
-
-void AliEventCut::SetNChargedRange(Int_t min,Int_t max,Double_t etamin,Double_t etamax)
-{
- //Sets renge of number of charged particles
-  AliNChargedCut* cut = dynamic_cast<AliNChargedCut*>(FindCut(AliEventBaseCut::kNChargedCut));
-  if(cut) 
-   { 
-     cut->SetRange(min,max);
-     cut->SetEtaRange(etamin,etamax);
-   }  
-  else fBaseCuts.Add(new AliNChargedCut(min,max,etamin,etamax));
-}
-/*********************************************************/
-
-void AliEventCut::SetVertexXRange(Double_t min, Double_t max)
-{
-  //Sets range of z coordinate of a primary vertex
-  AliEventBaseCut* cut = FindCut(AliEventBaseCut::kPrimVertexXCut);
-  if (cut) cut->SetRange(min,max);
-  else fBaseCuts.Add(new AliPrimVertexXCut(min,max));
-}
-/*********************************************************/
-
-void AliEventCut::SetVertexYRange(Double_t min, Double_t max)
-{
-  //Sets range of z coordinate of a primary vertex
-  AliEventBaseCut* cut = FindCut(AliEventBaseCut::kPrimVertexYCut);
-  if (cut) cut->SetRange(min,max);
-  else fBaseCuts.Add(new AliPrimVertexYCut(min,max));
-}
-/*********************************************************/
-
-void AliEventCut::SetVertexZRange(Double_t min, Double_t max)
-{
-  //Sets range of z coordinate of a primary vertex
-  AliEventBaseCut* cut = FindCut(AliEventBaseCut::kPrimVertexZCut);
-  if (cut) cut->SetRange(min,max);
-  else fBaseCuts.Add(new AliPrimVertexZCut(min,max));
-}
-/*********************************************************/
-/*********************************************************/
-/*********************************************************/
-
-ClassImp(AliEventEmptyCut)
diff --git a/ANALYSIS/AliEventCut.h b/ANALYSIS/AliEventCut.h
deleted file mode 100644 (file)
index 198fd5b..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef ALIEVENTCUT_H
-#define ALIEVENTCUT_H
-
-///////////////////////////////////////////////////////////
-//
-// class AliEventCut
-//
-// Event cut. It has list of base event cuts. 
-// Each of base event cut checks only one property.
-// Logical base cuts also exists that point to other base cuts.
-// Using them one can build complicated cut with binary tree structure
-// Author: Piotr.Skowronski@cern.ch
-///////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include <TObjArray.h>
-#include "AliEventBaseCut.h"
-
-class AliAOD;
-
-class AliEventCut: public TObject
-{
-  public: 
-    AliEventCut();
-    AliEventCut(const AliEventCut& in);
-    virtual ~AliEventCut();
-    
-    virtual Bool_t Rejected(AliAOD* aod) const;//returns kTRUE if rejected
-    void           AddBasePartCut(AliEventBaseCut* ebcut);
-
-    void           SetNChargedRange(Int_t min,Int_t max, Double_t etamin = -10.0,Double_t etamax = 10.0);
-    void           SetVertexXRange(Double_t min, Double_t max);
-    void           SetVertexYRange(Double_t min, Double_t max);
-    void           SetVertexZRange(Double_t min, Double_t max);
-    
-  protected:
-    AliEventBaseCut* FindCut(AliEventBaseCut::EEventCutProperty prop);
-    
-    TObjArray fBaseCuts; // Array of cuts
-  private:
-    ClassDef(AliEventCut,1)
-};
-
-class AliEventEmptyCut: public TObject
-{
-  public: 
-    AliEventEmptyCut(){}
-    virtual ~AliEventEmptyCut(){}
-    
-    Bool_t Rejected(AliAOD* /*aod*/) const {return kFALSE;}//always accept
-    
-  protected:
-  private:
-    ClassDef(AliEventEmptyCut,1)
-};
-
-#endif
diff --git a/ANALYSIS/AliFlowAnalysis.cxx b/ANALYSIS/AliFlowAnalysis.cxx
deleted file mode 100644 (file)
index e5ddd3c..0000000
+++ /dev/null
@@ -1,221 +0,0 @@
-#include "AliFlowAnalysis.h"
-
-//*********************************************************
-// class AliFlowAnalysis
-// Flow Analysis
-// S.Radomski@gsi.de
-// Piotr.Skowronski@cern.ch
-//*********************************************************
-
-#include <AliAOD.h>
-#include <AliVAODParticle.h>
-#include <AliAODParticleCut.h>
-
-#include <AliESDtrack.h>
-#include <AliESD.h>
-
-ClassImp(AliFlowAnalysis)
-
-AliFlowAnalysis::AliFlowAnalysis():
- fPartCut(0x0)
-{
- //ctor
-}
-/*********************************************************/
-
-AliFlowAnalysis::~AliFlowAnalysis()
-{
- //dtor
-  delete fPartCut;
-}
-/*********************************************************/
-
-Int_t AliFlowAnalysis::Init()
-{
-  //Initilizes anaysis
-  Info("Init","");
-  return 0; 
-}
-/*********************************************************/
-
-Int_t AliFlowAnalysis::ProcessEvent(AliAOD* aodrec, AliAOD* aodsim)
-{
-  // Process AOD events containing the reconstructed and simulated information
-  Info("ProcessEvent","Sim AOD address %#x",aodsim);
-  Double_t psi = 0, v2 = 0;
-  if (aodrec)
-   {
-     GetFlow(aodrec,v2,psi);
-     Info("ProcessEvent","Reconstructed Event: Event plane is %f, V2 is %f",psi,v2);
-   }  
-
-  if (aodsim)
-   {
-     GetFlow(aodsim,v2,psi);
-     Info("ProcessEvent","Simulated Event: Event plane is %f, V2 is %f",psi,v2);
-   }  
-  
-  return 0;
-  
-}
-/*********************************************************/
-
-Int_t AliFlowAnalysis::Finish()
-{
-  //Finish analysis and writes results
-  Info("Init","Finish");
-  return 0;
-}
-/*********************************************************/
-
-Double_t AliFlowAnalysis::GetEventPlane(AliAOD* aod)
-{
-  //returns event plane in degrees
-  if (aod == 0x0)
-   {
-     Error("AliFlowAnalysis::GetFlow","Pointer to AOD is NULL");
-     return -1.0;
-   }
-
-  Double_t psi;
-  Int_t mult = aod->GetNumberOfParticles();
-  
-  Double_t ssin = 0, scos = 0;
-
-  for (Int_t i=0; i<mult; i++) 
-   {
-     AliVAODParticle* aodtrack = aod->GetParticle(i);
-     if (aodtrack == 0x0)
-      {
-        Error("AliFlowAnalysis::GetEventPlane","Can not get track %d", i);
-        continue;
-      }
-     
-     if (fPartCut)
-      if (fPartCut->Rejected(aodtrack))
-        continue;
-
-     Double_t phi = TMath::Pi()+TMath::ATan2(-aodtrack->Py(),-aodtrack->Px()); 
-     
-     ssin += TMath::Sin( 2.0 * phi );
-     scos += TMath::Cos( 2.0 * phi );
-   }
-
-  psi = atan2 (ssin, scos) / 2.0;
-  psi = psi * 180. / TMath::Pi(); 
-  
-  return psi;
-
-}
-/*********************************************************/
-
-void AliFlowAnalysis::GetFlow(AliAOD* aod,Double_t& v2,Double_t& psi)
-{
-//returns flow parameters: v2 and event plane
-  if (aod == 0x0)
-   {
-     Error("AliFlowAnalysis::GetFlow","Pointer to AOD is NULL");
-     return;
-   }
-   
-  psi = GetEventPlane(aod);
-  Int_t mult = aod->GetNumberOfParticles();
-  
-  Double_t ssin = 0, scos = 0;
-
-  for (Int_t i=0; i<mult; i++) 
-   {
-     AliVAODParticle* aodtrack = aod->GetParticle(i);
-     if (aodtrack == 0x0)
-      {
-        Error("AliFlowAnalysis::GetEventPlane","Can not get track %d", i);
-        continue;
-      }
-     if (fPartCut)
-      if (fPartCut->Rejected(aodtrack))
-        continue;
-      
-     Double_t phi = TMath::Pi()+TMath::ATan2(-aodtrack->Py(),-aodtrack->Px()); 
-     ssin += TMath::Sin( 2.0 * (phi - psi));
-     scos += TMath::Cos( 2.0 * (phi - psi));
-   }
-   
-  v2 = TMath::Hypot(ssin,scos);
-}
-
-
-/*********************************************************/
-
-Double_t AliFlowAnalysis::GetEventPlane(AliESD* esd)
-{
-  //returns event plane
-  if (esd == 0x0)
-   {
-     ::Error("AliFlowAnalysis::GetFlow","Pointer to ESD is NULL");
-     return -1.0;
-   }
-
-  Double_t psi;
-  Int_t mult = esd->GetNumberOfTracks();
-  
-  Double_t ssin = 0, scos = 0;
-
-  for (Int_t i=0; i<mult; i++) 
-   {
-     AliESDtrack* esdtrack = esd->GetTrack(i);
-     if (esdtrack == 0x0)
-      {
-        ::Error("AliFlowAnalysis::GetEventPlane","Can not get track %d", i);
-        continue;
-      }
-      
-     Double_t mom[3];//momentum
-     esdtrack->GetPxPyPz(mom); 
-     Double_t phi = TMath::Pi()+TMath::ATan2(-mom[1],-mom[0]); 
-     
-     ssin += TMath::Sin( 2.0 * phi );
-     scos += TMath::Cos( 2.0 * phi );
-   }
-
-  psi = atan2 (ssin, scos) / 2.0;
-  psi = psi * 180. / TMath::Pi(); 
-  
-  return psi;
-
-}
-/*********************************************************/
-
-void AliFlowAnalysis::GetFlow(AliESD* esd,Double_t& v2,Double_t& psi)
-{
-//returns flow parameters: v2 and event plane
-  if (esd == 0x0)
-   {
-     ::Error("AliFlowAnalysis::GetFlow","Pointer to ESD is NULL");
-     return;
-   }
-   
-  psi = GetEventPlane(esd);
-  Int_t mult = esd->GetNumberOfTracks();
-  
-  Double_t ssin = 0, scos = 0;
-
-  for (Int_t i=0; i<mult; i++) 
-   {
-     AliESDtrack* esdtrack = esd->GetTrack(i);
-     if (esdtrack == 0x0)
-      {
-        ::Error("AliFlowAnalysis::GetEventPlane","Can not get track %d", i);
-        continue;
-      }
-      
-     Double_t mom[3];//momentum
-     esdtrack->GetPxPyPz(mom); 
-     Double_t phi = TMath::Pi()+TMath::ATan2(-mom[1],-mom[0]); 
-     
-     ssin += TMath::Sin( 2.0 * (phi - psi));
-     scos += TMath::Cos( 2.0 * (phi - psi));
-   }
-   
-  v2 = TMath::Hypot(ssin,scos);
-}
-/*********************************************************/
diff --git a/ANALYSIS/AliFlowAnalysis.h b/ANALYSIS/AliFlowAnalysis.h
deleted file mode 100644 (file)
index ea6c003..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef ALIFLOWANALYSIS_H
-#define ALIFLOWANALYSIS_H
-
-//*********************************************************
-// class AliFlowAnalysis
-// Flow Analysis
-// S.Radomski@gsi.de
-// Piotr.Skowronski@cern.ch
-//*********************************************************
-
-#include "AliAnalysis.h"
-
-class AliESD;
-class AliAOD;
-class AliStack;
-class AliAODParticleCut;
-    
-class AliFlowAnalysis: public AliAnalysis
-{ 
-  public: 
-     AliFlowAnalysis();
-     virtual ~AliFlowAnalysis();
-
-    Int_t Init();
-    Int_t ProcessEvent(AliAOD* aodrec, AliAOD* aodsim = 0x0);
-    Int_t Finish();
-   
-    void SetParticleCut(AliAODParticleCut* pcut){fPartCut = pcut;}
-    static Double_t GetEventPlane(AliESD* esd);
-    static void     GetFlow(AliESD* esd,Double_t& v2,Double_t& psi);
-
-    Double_t        GetEventPlane(AliAOD* aod);
-    void            GetFlow(AliAOD* aod,Double_t& v2,Double_t& psi);
-  protected:
-    
-  private:
-    AliAODParticleCut* fPartCut;//Particle Cut
-
-    AliFlowAnalysis(const AliFlowAnalysis&); // Not implemented
-    AliFlowAnalysis& operator=(const AliFlowAnalysis&); // Not implemented
-
-    ClassDef(AliFlowAnalysis,1)
-};
-
-#endif
diff --git a/ANALYSIS/AliMuonAnalysis.cxx b/ANALYSIS/AliMuonAnalysis.cxx
deleted file mode 100644 (file)
index 5dc9a1c..0000000
+++ /dev/null
@@ -1,189 +0,0 @@
-#include "AliMuonAnalysis.h"
-//________________________________
-///////////////////////////////////////////////////////////
-//
-// class AliMuonAnalysis
-//
-// MUON Analysis
-//
-//
-// 
-// finck@subatech.in2p3.fr
-//
-///////////////////////////////////////////////////////////
-/*********************************************************/
-
-#include <TString.h>
-#include <TParticle.h>
-
-#include <AliStack.h>
-#include <AliAOD.h>
-#include <AliAODParticle.h>
-#include <AliAODParticleCut.h>
-
-#include <AliESDtrack.h>
-#include <AliESD.h>
-
-#include "TFile.h"
-#include "TH1.h"
-#include "TH2.h"
-
-ClassImp(AliMuonAnalysis)
-
-AliMuonAnalysis::AliMuonAnalysis():
-  fHistoFile(0x0),
-  fHPtMuon(0x0),
-  fHPtMuonPlus(0x0),
-  fHPtMuonMinus(0x0),
-  fHPMuon(0x0),
-  fHInvMassAll(0x0),
-  fHRapMuon(0x0),
-  fHRapResonance(0x0),
-  fHPtResonance(0x0),
-  fHInvMassAllvsPt(0x0),
-  fPartCut(0x0)
-{
- //ctor
-}
-
-/*********************************************************/
-AliMuonAnalysis::~AliMuonAnalysis()
-{
- //dtor
-  delete fPartCut;
-  delete fHistoFile;
-  delete fHPtMuon;
-  delete fHPtMuonPlus;
-  delete fHPtMuonMinus;
-  delete fHPMuon;
-  delete fHInvMassAll;
-  delete fHRapMuon;
-  delete fHRapResonance;
-  delete fHPtResonance;
-  delete fHInvMassAllvsPt;
-}
-/*********************************************************/
-
-Int_t AliMuonAnalysis::Init()
-{
-  //Initilizes analysis
-  Info("Init","Histo initialized for MUON Analysis");
-
-  fHistoFile         = new TFile("MUONmassPlot.root", "RECREATE");
-  fHPtMuon           = new TH1F("hPtMuon", "Muon Pt (GeV/c)", 100, 0., 20.);
-  fHPMuon            = new TH1F("hPMuon", "Muon P (GeV/c)", 100, 0., 200.);
-  fHPtMuonPlus       = new TH1F("hPtMuonPlus", "Muon+ Pt (GeV/c)", 100, 0., 20.);
-  fHPtMuonMinus      = new TH1F("hPtMuonMinus", "Muon- Pt (GeV/c)", 100, 0., 20.);
-  fHInvMassAll       = new TH1F("hInvMassAll", "Mu+Mu- invariant mass (GeV/c2)", 480, 0., 12.);
-  fHRapMuon          = new TH1F("hRapMuon"," Muon Rapidity",50,-4.5,-2);
-  fHRapResonance     = new TH1F("hRapResonance"," Resonance Rapidity",50,-4.5,-2);
-  fHPtResonance      = new TH1F("hPtResonance", "Resonance Pt (GeV/c)", 100, 0., 20.);
-  fHInvMassAllvsPt = new TH2F("hInvMassAll_vs_Pt","hInvMassAll_vs_Pt",480,0.,12.,80,0.,20.);
-
-  return 0; 
-}
-/*********************************************************/
-
-Int_t AliMuonAnalysis::ProcessEvent(AliAOD* aodrec, AliAOD* aodsim)
-{
-  //
-  // process the event
-  // 
-  if (aodrec) {
-    GetInvMass(aodrec);
-    //    Info("ProcessEvent","Inv Mass Rec");
-  }  
-
-  if (aodsim) {
-    //     Info("ProcessEvent","aodsim not implemented");
-  }  
-  
-  return 0;
-  
-}
-
-/*********************************************************/
-
-Int_t AliMuonAnalysis::Finish()
-{
-  //Finish analysis and writes results
-  Info("Finish","Histo writing for MUON Analysis");
-
-  fHistoFile->Write();
-  fHistoFile->Close();
-
-  return 0;
-}
-/*********************************************************/
-
-void AliMuonAnalysis::GetInvMass(AliAOD* aod)
-{
-  // get the invariant mass distribution
-  // from the oad events
-  TLorentzVector lorV1, lorV2, lorVtot;
-  Float_t massMin = 9.17;
-  Float_t massMax = 9.77;
-  Int_t charge1, charge2;
-
-//returns flow parameters: v2 and event plane
-  if (aod == 0x0) {
-     Error("AliMuonAnalysis::GetInvMass","Pointer to AOD is NULL");
-     return;
-  }
-   
-  Int_t nPart = aod->GetNumberOfParticles();
-  
-  for (Int_t iPart1 = 0; iPart1 < nPart; iPart1++)  {
-    AliAODParticle* aodPart1 =  (AliAODParticle*)aod->GetParticle(iPart1);
-
-    if (aodPart1 == 0x0) {
-      Error("AliMuonAnalysis::GetInvMass","Cannot get particle %d", iPart1);
-      continue;
-    }
-
-    lorV1.SetPxPyPzE(aodPart1->Px(),
-                        aodPart1->Py(),
-                        aodPart1->Pz(),
-                        aodPart1->E());
-
-    fHPtMuon->Fill(lorV1.Pt());
-    fHPMuon->Fill(lorV1.P());
-
-    charge1 = TMath::Sign(1,aodPart1->GetPdgCode());
-
-    if (charge1 > 0) {
-      fHPtMuonPlus->Fill(lorV1.Pt());
-    } else {
-      fHPtMuonMinus->Fill(lorV1.Pt());
-    }
-    fHRapMuon->Fill(lorV1.Rapidity());
-    for (Int_t iPart2 = iPart1 + 1; iPart2 < nPart; iPart2++)  {
-
-      AliAODParticle* aodPart2 =  (AliAODParticle*)aod->GetParticle(iPart2);
-
-      lorV2.SetPxPyPzE(aodPart2->Px(),
-                        aodPart2->Py(),
-                        aodPart2->Pz(),
-                        aodPart2->E());
-
-      charge2 = TMath::Sign(1,aodPart2->GetPdgCode());
-
-      if ((charge1 * charge2) == -1) {
-
-       lorVtot = lorV1;
-       lorVtot += lorV2;
-       Float_t invMass = lorVtot.M();
-
-       fHInvMassAll->Fill(invMass);
-       fHInvMassAllvsPt->Fill(invMass,lorVtot.Pt());
-
-       if (invMass > massMin && invMass < massMax) {
-         fHRapResonance->Fill(lorVtot.Rapidity());
-         fHPtResonance->Fill(lorVtot.Pt());
-       }
-      }
-
-    }
-  }
-}
diff --git a/ANALYSIS/AliMuonAnalysis.h b/ANALYSIS/AliMuonAnalysis.h
deleted file mode 100644 (file)
index d158e0d..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifndef ALIMUONANALYSIS_H
-#define ALIMUONANALYSIS_H
-//________________________________
-///////////////////////////////////////////////////////////
-//
-// class AliMuonAnalysis
-//
-// Flow Analysis
-//
-//
-// S.Radomski@gsi.de
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////
-
-#include "AliAnalysis.h"
-
-class AliESD;
-class AliAOD;
-class AliStack;
-class AliAODParticleCut;
-class TFile;
-class TH1F;
-class TH2F;
-
-class AliMuonAnalysis: public AliAnalysis
-{ 
-  public: 
-     AliMuonAnalysis();
-     virtual ~AliMuonAnalysis();
-
-    Int_t Init();
-    Int_t ProcessEvent(AliAOD* aodrec, AliAOD* aodsim);
-    Int_t Finish();
-   
-    void SetParticleCut(AliAODParticleCut* pcut){fPartCut = pcut;}
-
-    void GetInvMass(AliAOD* aod);
-
-  protected:
-    
-  private:
-
-    TFile *fHistoFile;         // histogramm file pointer
-    TH1F *fHPtMuon;            // Muon Pt distribution
-    TH1F *fHPtMuonPlus;        // Muon Plus Pt distribution
-    TH1F *fHPtMuonMinus;       // Muon Minus Pt distribution
-    TH1F *fHPMuon;             // Muon momentum distribution
-    TH1F *fHInvMassAll;        // Invariant mass distribution
-    TH1F *fHRapMuon;           // Muon rapidity distribution
-    TH1F *fHRapResonance;      // Muon rapidity distribution around resonance
-    TH1F *fHPtResonance;       // Muon Pt distribution around resonance
-    TH2F *fHInvMassAllvsPt;    // Invariant mass vs Pt distribution
-
-    AliAODParticleCut* fPartCut;//Particle Cut
-
-    AliMuonAnalysis(const AliMuonAnalysis&); // Not implemented
-    AliMuonAnalysis& operator=(const AliMuonAnalysis&); // Not implemented
-
-    ClassDef(AliMuonAnalysis,1)
-};
-
-#endif
diff --git a/ANALYSIS/AliReader.cxx b/ANALYSIS/AliReader.cxx
deleted file mode 100644 (file)
index df65af7..0000000
+++ /dev/null
@@ -1,501 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-//_________________________________________________________________________
-///////////////////////////////////////////////////////////////////////////
-//
-// class AliReader
-//
-// Reader Base class 
-// Reads particles and tracks and
-// puts them to the AliAOD objects and eventually, if needed, buffers AliAODs in AliAODRun(s)
-//
-// User loops over events calling method Next. In case of success this method returns 0.
-// In case of error or if there is no more events to read, non-0 value is returned
-//
-// Reading can be rewound to the beginning using method Rewind.
-//
-// Tracks are read to the fEventRec (contains reconstructed tracks) 
-// and fEventSim (corresponding MC simulated data) data members,
-// that are of the type AliAOD. 
-//
-// If a given reader has ability of reading both, reconstructed and simulated data, 
-// these are structured in AODs so a "n'th" simulated particle 
-// (the one stored in the fEventSim at slot n) 
-// corresponds to the n'th reconstructed track (the one stored in the fEventRec at slot n).
-//
-// The same reconstructed track can be present more than ones in the AOD,
-// but with a different PID. In this case
-// pointer to the corresponding MC simulated particles is also present more than ones.
-// This situation happens if you want to read all particles 
-// with PID probability of being , e.g.,  pion higher than 60%
-// and being kaon higher than 40%. Than, if a given track has probability Ppid(pi)=52% and Ppid(K)=48% 
-// than it is read twise.
-//
-// Provides functionality for both buffering and non-buffering reading
-// This can be switched on/off via method SetEventBuffering(bool)
-// The main method that inheriting classes need to implement is ReadNext()
-// that read next event in queue.
-//
-// The others are:
-// Bool_t  ReadsRec() const; specifies if reader is able to read simulated particles
-// Bool_t  ReadsSim() const; specifies if reader is able to read reconstructed tracks
-// void    Rewind(); rewind reading to the beginning
-//
-// This class provides full functionality for reading from many sources
-// User can provide TObjArray of TObjStrings (SetDirs method or via parameter 
-// in the constructor) which desribes paths of directories to search data in.
-// If none specified current directory is searched.
-// 
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////////////////////
-
-#include <TClass.h>
-#include <TGliteXmlEventlist.h>
-#include <TH1.h>
-#include <TObjArray.h>
-#include <TObjString.h>
-#include <TRandom.h>
-#include <TString.h>
-
-#include "AliAOD.h"
-#include "AliAODParticleCut.h"
-#include "AliAODRun.h"
-#include "AliLog.h"
-#include "AliReader.h"
-ClassImp(AliReader)
-//pure virtual
-    
-/*************************************************************************************/
-
-AliReader::AliReader():
- fEventList(0x0),
- fCuts(new TObjArray()),
- fDirs(0x0),
- fCurrentEvent(0),
- fCurrentDir(0),
- fNEventsRead(0),
- fEventRec(0x0),
- fEventSim(0x0),
- fRunSim(0x0),
- fRunRec(0x0),
- fIsRead(kFALSE),
- fBufferEvents(kFALSE),
- fBlend(kFALSE),
- fFirst(0),
- fLast(0),
- fTrackCounter(0x0)
-{
-//constructor
-}
-/*************************************************************************************/
-
-AliReader::AliReader(TObjArray* dirs):
- fEventList(0x0),
- fCuts(new TObjArray()),
- fDirs(dirs),
- fCurrentEvent(0),
- fCurrentDir(0),
- fNEventsRead(0),
- fEventRec(0x0),
- fEventSim(0x0),
- fRunSim(0x0),
- fRunRec(0x0),
- fIsRead(kFALSE),
- fBufferEvents(kFALSE),
- fBlend(kFALSE),
- fFirst(0),
- fLast(0),
- fTrackCounter(0x0)
-{
-//ctor with array of directories to read as parameter
-}
-/*************************************************************************************/
-AliReader::AliReader(const AliReader& in):
- TNamed(in),
- fEventList((in.fEventList)?(TGliteXmlEventlist*)in.fEventList->Clone():0x0),
- fCuts((in.fCuts)?(TObjArray*)in.fCuts->Clone():0x0),
- fDirs((in.fDirs)?(TObjArray*)in.fDirs->Clone():0x0),
- fCurrentEvent(0),
- fCurrentDir(0),
- fNEventsRead(0),
- fEventRec(0x0),
- fEventSim(0x0),
- fRunSim(0x0),
- fRunRec(0x0),
- fIsRead(kFALSE),
- fBufferEvents(in.fBufferEvents),
- fBlend(in.fBlend),
- fFirst(in.fFirst),
- fLast(in.fLast),
- fTrackCounter(0x0)
-{
- //cpy constructor
-}
-
-AliReader::~AliReader()
-{
-//destructor
- if(fCuts)
-  {
-   fCuts->SetOwner();
-   delete fCuts;
-  }
- delete fEventSim;
- delete fEventRec;
- delete fTrackCounter;
- delete fEventList;
-}
-/*************************************************************************************/
-
-AliReader& AliReader::operator=(const AliReader& in)
-{
-  //Assigment operator
- if (this == &in) return *this;  
- TNamed::operator=( (const TNamed&)in );
-  
- fCuts = (in.fCuts)?(TObjArray*)in.fCuts->Clone():0x0;
- fDirs = (in.fDirs)?(TObjArray*)in.fDirs->Clone():0x0;
- fCurrentEvent = 0;
- fCurrentDir = 0;
- fNEventsRead = 0;
- fEventRec = 0x0;
- fEventSim = 0x0;
- fRunSim = 0x0;
- fRunRec = 0x0;
- fIsRead = kFALSE;
- fBufferEvents = in.fBufferEvents;
- fBlend = in.fBlend;
- fFirst = in.fFirst;
- fLast = in.fLast;
- fTrackCounter = 0x0;
- return *this;  
-}
-/*************************************************************************************/
-
-Int_t AliReader::Next()
-{
-//moves to next event
-
-  //if asked to read up to event nb. fLast, and it is overcome, report no more events
-  if ((fNEventsRead >= fLast) && (fLast > 0) ) return kTRUE;
-  
-  if (fTrackCounter == 0x0)//create Track Counter
-   {
-     fTrackCounter = new TH1I("trackcounter","Track Counter",20000,0,20000);
-     fTrackCounter->SetDirectory(0x0);
-   }
-  
-  do //if asked to read from event fFirst, rewind to it
-   {
-    if ( ReadNext() == kTRUE) //if no more evets, return it
-      return kTRUE;
-   }while (fNEventsRead < fFirst);
-   
-  //here we have event
-  
-  if (fBlend) Blend();//Mix particles order 
-  
-  if (fBufferEvents)//store events if buffering is on
-   {
-     if ( ReadsRec() && fEventRec) 
-       fRunRec->SetEvent(fNEventsRead-1-fFirst,fEventRec);
-     if ( ReadsSim() && fEventSim)
-       fRunSim->SetEvent(fNEventsRead-1-fFirst,fEventSim);
-   }
-  return kFALSE;
-}
-/*************************************************************************************/
-
-void AliReader::AddParticleCut(AliAODParticleCut* cut)
-{
- //sets the new cut. MAKES A COPY OF THE CUT !!!!
-  if (!cut) //if cut is NULL return with error
-   {
-    Error("AddParticleType","NULL pointers are not accepted any more.\nIf You want to accept all particles of this type, set an empty cut ");
-    return;
-   }
-  AliAODParticleCut *c = (AliAODParticleCut*)cut->Clone();
-  fCuts->Add(c);
-}
-/********************************************************************/
-
-AliAOD* AliReader::GetEventSim(Int_t n)
- {
- //returns Nth event with simulated particles
-  if (ReadsSim() == kFALSE)
-   {
-     Error("GetParticleEvent","This reader is not able to provide simulated particles.");
-     return 0;
-   } 
-   
-  if (!fIsRead) 
-   { 
-    if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun();
-    if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun();
-    
-    if (Read(fRunSim,fRunRec))
-     {
-       Error("GetParticleEvent","Error in reading");
-       return 0x0;
-     }
-    else fIsRead = kTRUE;
-   }
-  return fRunSim->GetEvent(n);
- }
-/********************************************************************/
-
-AliAOD* AliReader::GetEventRec(Int_t n)
- {
- //returns Nth event with reconstructed tracks
-  if (ReadsRec() == kFALSE)
-   {
-     Error("GetTrackEvent","This reader is not able to provide recosntructed tracks.");
-     return 0;
-   } 
-  if (!fIsRead) 
-   {
-    if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun();
-    if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun();
-    
-    if(Read(fRunSim,fRunRec))
-     {
-       Error("GetTrackEvent","Error in reading");
-       return 0x0;
-     }
-    else fIsRead = kTRUE;
-   }
-  return fRunRec->GetEvent(n);
- }
-/********************************************************************/
-
-Int_t AliReader::GetNumberOfSimEvents()
- {
- //returns number of events of particles
-  if (ReadsSim() == kFALSE)
-   {
-     Error("GetNumberOfPartEvents","This reader is not able to provide simulated particles.");
-     return 0;
-   } 
-   
-  if (!fIsRead) 
-   {
-    if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun();
-    if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun();
-    
-    if (Read(fRunSim,fRunRec))
-     {
-       Error("GetNumberOfPartEvents","Error in reading");
-       return 0;
-     }
-    else fIsRead = kTRUE;
-   }
-   return fRunSim->GetNumberOfEvents();
- }
-/********************************************************************/
-Int_t AliReader::GetNumberOfRecEvents()
- {
- //returns number of events of tracks
-  if (ReadsRec() == kFALSE)
-   {
-     Error("GetNumberOfTrackEvents","This reader is not able to provide recosntructed tracks.");
-     return 0;
-   } 
-  if (!fIsRead)
-   {
-     if (ReadsSim() && (fRunSim == 0x0)) fRunSim = new AliAODRun();
-     if (ReadsRec() && (fRunRec == 0x0)) fRunRec = new AliAODRun();
-     
-     if(Read(fRunSim,fRunRec))
-      {
-        Error("GetNumberOfTrackEvents","Error in reading");
-        return 0;
-      }
-     else fIsRead = kTRUE;
-   }
-  return fRunRec->GetNumberOfEvents();
- }
-/********************************************************************/
-
-Int_t AliReader::Read(AliAODRun* particles, AliAODRun *tracks)
-{
- //reads data and puts put to the particles and tracks objects
- //reurns 0 if everything is OK
- //
-  Info("Read","");
-  
-  if ( ReadsSim() && (particles == 0x0) ) //check if an object is instatiated
-   {
-     Error("Read"," particles object must be instatiated before passing it to the reader");
-     return 1;
-   }
-  if ( ReadsRec() && (tracks == 0x0) )  //check if an object is instatiated
-   {
-     Error("Read"," tracks object must be instatiated before passing it to the reader");
-     return 1;
-   }
-   
-  if (ReadsSim()) particles->Reset();//clear runs == delete all old events
-  if (ReadsRec()) tracks->Reset();
-  
-  Rewind();
-  
-  Int_t i = 0;
-  while(Next() == kFALSE)
-   {
-     if (ReadsRec()) tracks->SetEvent(i,fEventRec);
-     if (ReadsSim()) particles->SetEvent(i,fEventSim);
-     i++;
-   }
-  return 0;
-}      
-/*************************************************************************************/
-
-Bool_t AliReader::Rejected(AliVAODParticle* p)
-{
- //Method examines whether particle meets all cut and particle type criteria
-  
-   if(p==0x0)//of corse we not pass NULL pointers
-    {
-     Warning("Rejected()","No Pasaran! We never accept NULL pointers");
-     return kTRUE;
-    }
-   //if no particle is specified, we pass all particles
-   //excluding NULL pointers, of course
-  if ( fCuts->GetEntriesFast() == 0 ) return kFALSE; //if no cut specified accept all particles
-  for(Int_t i=0; i<fCuts->GetEntriesFast(); i++)   
-   {
-     AliAODParticleCut &cut = *((AliAODParticleCut*)fCuts->At(i));
-     if(!cut.Rejected(p)) return kFALSE;  //accepted
-   }
-   
-  return kTRUE;//not accepted
-}
-/*************************************************************************************/
-
-Bool_t  AliReader::Rejected(Int_t pid)
-{
-//this method checks if any of existing cuts accepts this pid particles
-//or any cuts accepts all particles
-
- if(pid == 0)
-  return kTRUE;
-
- if ( fCuts->GetEntriesFast() == 0 ) return kFALSE; //if no cut specified accept all particles
-  
- for(Int_t i=0; i<fCuts->GetEntriesFast(); i++)   
-   {
-     AliAODParticleCut &cut = *((AliAODParticleCut*)fCuts->At(i));
-     //if some of cuts accepts all particles or some accepts particles of this type, accept
-     if ( (cut.GetPID() == 0) || (cut.GetPID() == pid) ) return kFALSE; 
-   }
- return kTRUE;
-}
-/*************************************************************************************/
-
-TString AliReader::GetDirName(Int_t entry)
-{
-//returns directory name of next one to read
-  TString  retval;//return value
-  if (fDirs ==  0x0)
-   { 
-     if (entry == 0)
-      {
-       retval = ".";
-       return retval;
-      }
-     else
-      {
-       return retval;
-      }  
-   }
-  
-  
-  if ( (entry >= fDirs->GetEntries()) || (entry < 0))//if out of bounds return empty string
-   {                                            //note that entry==0 is accepted even if array is empty (size=0)
-    if ( (fDirs->GetEntries() == 0) && (entry == 0) )
-      { 
-        retval = ".";
-        return retval;
-      }
-     AliDebug(1,Form("Index %d out of bounds",entry));
-
-     return retval;
-   }
-
-
-  TClass *objclass = fDirs->At(entry)->IsA();
-  TClass *stringclass = TObjString::Class();
-
-  TObjString *dir = (TObjString*)objclass->DynamicCast(stringclass,fDirs->At(entry));
-
-  if(dir == 0x0)
-   {
-     Error("GetDirName","Object in TObjArray is not a TObjString or its descendant");
-     return retval;
-   }
-  AliDebug(1,Form("Returned ok %s",dir->String().Data()));
-  retval = dir->String();
-  return retval;
-}
-/*************************************************************************************/
-
-void AliReader::Blend()
-{
-  //randomly change positions of the particles after reading
-  //is used to check if some distributions (of many particle properties) 
-  //depend on the order of particles
-  //(tracking gives particles Pt sorted)
-  Int_t npart = 0;
-
-  if (fEventSim ) 
-   {
-     npart = fEventSim->GetNumberOfParticles();
-    } 
-  else 
-    if (fEventRec ) 
-     {
-        npart = fEventRec->GetNumberOfParticles();
-     }
-    else
-     {
-       return;
-     }
-  for (Int_t i = 2;  i < npart; i++)
-   {
-     Int_t with = gRandom->Integer(i);
-//     Info("Blend","%d %d",i, with);
-     if (fEventSim) fEventSim->SwapParticles(i,with);
-     if (fEventRec) fEventRec->SwapParticles(i,with);
-   }
-}
-/*************************************************************************************/
-
-void AliReader::WriteTrackCounter() const
-{
- //writes the counter histogram
- if (fTrackCounter) fTrackCounter->Write(0,TObject::kOverwrite);
- else 
-  {
-    Warning("WriteTrackCounter","Counter is NULL");
-  }
-}
diff --git a/ANALYSIS/AliReader.h b/ANALYSIS/AliReader.h
deleted file mode 100644 (file)
index 7988dfd..0000000
+++ /dev/null
@@ -1,146 +0,0 @@
-#ifndef ALIREADER_H
-#define ALIREADER_H
-//_________________________________________________________________________
-///////////////////////////////////////////////////////////////////////////
-//
-// class AliReader
-//
-// Reader Base class 
-// Reads particles and tracks and
-// puts them to the AliAOD objects and eventually, if needed, buffers AliAODs in AliAODRun(s)
-//
-// User loops over events calling method Next. In case of success this method returns 0.
-// In case of error or if there is no more events to read, non-0 value is returned
-//
-// Reading can be rewound to the beginning using method Rewind.
-//
-// Tracks are read to the fEventRec (contains reconstructed tracks) 
-// and fEventSim (corresponding MC simulated data) data members,
-// that are of the type AliAOD. 
-//
-// If a given reader has ability of reading both, reconstructed and simulated data, 
-// these are structured in AODs so a "n'th" simulated particle 
-// (the one stored in the fEventSim at slot n) 
-// corresponds to the n'th reconstructed track (the one stored in the fEventRec at slot n).
-//
-// The same reconstructed track can be present more than ones in the AOD,
-// but with a different PID. In this case
-// pointer to the corresponding MC simulated particles is also present more than ones.
-// This situation happens if you want to read all particles 
-// with PID probability of being , e.g.,  pion higher than 60%
-// and being kaon higher than 40%. Than, if a given track has probability Ppid(pi)=52% and Ppid(K)=48% 
-// than it is read twise.
-//
-// Provides functionality for both buffering and non-buffering reading
-// This can be switched on/off via method SetEventBuffering(bool)
-// The main method that inheriting classes need to implement is ReadNext()
-// that read next event in queue.
-//
-// The others are:
-// Bool_t  ReadsSim() const; specifies if reader is able to read simulated particles
-// Bool_t  ReadsRec() const; specifies if reader is able to read reconstructed tracks
-// void    Rewind(); rewind reading to the beginning
-//
-// This class provides full functionality for reading from many sources
-// User can provide TObjArray of TObjStrings (SetDirs method or via parameter 
-// in the constructor) which desribes paths of directories to search data in.
-// If none specified current directory is searched.
-// 
-// Piotr.Skowronski@cern.ch
-//
-///////////////////////////////////////////////////////////////////////////
-
-#include <TNamed.h>
-#include <TObjArray.h>
-
-class TGliteXmlEventlist;
-    
-class AliAODRun;
-class AliAOD;
-class AliAODParticleCut;
-class AliVAODParticle;
-class TString;
-class TH1I;
-class AliReader: public TNamed
-{
-  public:
-    AliReader();
-    AliReader(TObjArray*);
-    AliReader(const AliReader& in);
-    virtual ~AliReader();
-    
-    AliReader& operator=(const AliReader& in);
-        
-    virtual Int_t        Next();
-    virtual void         Rewind() = 0; //
-    
-    virtual Bool_t       ReadsSim() const = 0; //specifies if reader is able to read simulated particles
-    virtual Bool_t       ReadsRec() const = 0;//specifies if reader is able to read reconstructed tracks
-
-    void                 AddParticleCut(AliAODParticleCut* cut);//adds a particle cut to the list of cuts
-    
-    virtual AliAOD*      GetEventRec() const {return fEventRec;}//returns current event with reconstructed tracks
-    virtual AliAOD*      GetEventSim() const {return fEventSim;}//returns current event with simulated particles
-    
-    virtual AliAOD*      GetEventRec(Int_t n);//returns event number n
-    virtual AliAOD*      GetEventSim(Int_t n);
-    
-    virtual Int_t        Read(const char * name) {return TObject::Read(name);}
-    virtual Int_t        Read(AliAODRun* particles, AliAODRun *tracks);//Reads all available evenets and stores them in 'particles' and 'tracks'
-
-    virtual Int_t        GetNumberOfRecEvents();//Returns number of available events -> usually conncected with reading all events
-                                                //may be time consuming
-    virtual Int_t        GetNumberOfSimEvents();// 
-     
-    void                 SetEventList(TGliteXmlEventlist* evl){fEventList = evl;}
-         
-    void                 SetDirs(TObjArray* dirs){fDirs = dirs;} //sets array directories names
-    void                 SetEventBuffering(Bool_t flag){fBufferEvents = flag;}//switches on/off buffering - read data are kept in local buffer
-    void                 SetBlend(Bool_t flag = kTRUE){fBlend=flag;} //set blending - randomizing particle order
-    virtual Int_t        GetNumberOfDirs() const {return (fDirs)?fDirs->GetEntries():0;}
-    void                 ReadEventsFromTo(Int_t first,Int_t last){fFirst = first; fLast = last;}
-    virtual TH1I*        GetTrackCounter() const {return fTrackCounter;}
-    virtual void         WriteTrackCounter() const;//Writes the track counting histigram 
-    
-  protected:
-    
-    TGliteXmlEventlist*  fEventList;//Event list delivered by GLite/AliEn
-    
-    TObjArray*           fCuts;//array with particle cuts
-    TObjArray*           fDirs;//arry with directories to read data from
-    
-    Int_t                fCurrentEvent;//!  number of current event in current directory
-    Int_t                fCurrentDir;//! number of current directory
-    
-    Int_t                fNEventsRead;//!total 
-        
-    AliAOD*              fEventRec;    //! tracks read from current event
-    AliAOD*              fEventSim;    //! particles read from current event
-    
-    AliAODRun*           fRunSim; //!simulated particles
-    AliAODRun*           fRunRec; //!reconstructed tracks
-    
-    Bool_t               fIsRead;//!flag indicating if the data are already read
-    Bool_t               fBufferEvents;//flag indicating if the data should be bufferred
-    
-    Bool_t               fBlend;// flag indicating if randomly change positions of the particles after reading
-    
-    Int_t                fFirst;//first event to return (all before are skipped)
-    Int_t                fLast;//the last one
-
-    TH1I*                fTrackCounter; //histogram with number of tracks read
-    
-    virtual Int_t        ReadNext() = 0; //this methods reads next event and put result in fTracksEvent and/or fParticlesEvent
-    Bool_t               Rejected(AliVAODParticle* p);//Checks if a given particle agains cuts
-    Bool_t               Rejected(Int_t pid);//Checks if a given pid passes cuts
-    void                 Blend();//Mixes current events in a symmetric way so after mixing thy are consistent
-    
-    TString              GetDirName(Int_t entry);
-    
-  private:
-  
-    ClassDef(AliReader,1)//
-};
-
-#endif
diff --git a/ANALYSIS/AliReaderAOD.cxx b/ANALYSIS/AliReaderAOD.cxx
deleted file mode 100644 (file)
index 234f8dc..0000000
+++ /dev/null
@@ -1,488 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-//______________________________________________________________________________
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// class AliReaderAOD                                                         //
-//                                                                            //
-// Reader and Writer for AOD format.                                          //
-// AODs are stored in a tree named by the variable fgkTreeName.               //
-// There is stored 1 or 2 branches. Each of them stores AOD objects           //
-// First branch is named by the variable fgkReconstructedDataBranchName       //
-// ("reconstructed.") and keeps reconstructed data.                           //
-// Second branch is called by the variable fgkSimulatedDataBranchName         //
-// ("simulated.") and stores Monte carlo truth. If both branches are present  //
-// AODs are parallel, i.e. nth particle in one branch corresponds to the nth  //
-// particle in the other one.                                                 //
-//                                                                            //
-// Since we accept different formats of particles that are stored in AODs     //
-// reader must take care of that fact: clean buffer if the next file contains //
-// different particle type.                                                   //
-//                                                                            //
-// Piotr.Skowronski@cern.ch                                                   //
-//                                                                            //
-////////////////////////////////////////////////////////////////////////////////
-
-
-#include <TError.h>
-#include <TFile.h>
-#include <TTree.h>
-#include <TH1.h>
-
-#include "AliAOD.h"
-#include "AliLog.h"
-#include "AliReaderAOD.h"
-
-const TString AliReaderAOD::fgkTreeName("TAOD");
-const TString AliReaderAOD::fgkReconstructedDataBranchName("reconstructed.");
-const TString AliReaderAOD::fgkSimulatedDataBranchName("simulated.");
-
-ClassImp(AliReaderAOD)
-
-AliReaderAOD::AliReaderAOD(const Char_t* aodfilename):
- fFileName(aodfilename),
- fReadSim(kFALSE),
- fReadRec(kTRUE),
- fTree(0x0),
- fFile(0x0),
- fSimBuffer(0x0),
- fRecBuffer(0x0)
-{
-  //ctor
-}
-/********************************************************************/
-
-AliReaderAOD::~AliReaderAOD()
-{
-//dtor
-  if (fEventSim == fSimBuffer )
-   {
-    fEventSim = 0x0;
-    fEventRec = 0x0;
-   }
-  delete fSimBuffer;
-  delete fRecBuffer;
-  
-  delete fTree;
-  delete fFile;
-}
-/********************************************************************/
-
-void AliReaderAOD::Rewind()
-{
-//Rewinds reading
-  delete fTree;
-  fTree = 0x0;
-  delete fFile;
-  fFile = 0x0;
-  fCurrentDir = 0;
-  fNEventsRead= 0;
-}
-/********************************************************************/
-Int_t AliReaderAOD::ReadNext()
-{
-//Reads next event
-  
-  Info("ReadNext","Entered");
-  do  //do{}while; is OK even if 0 dirs specified. In that case we try to read from "./"
-    {
-      if (fFile == 0x0)
-       {
-         Int_t openfailed = OpenFile(fCurrentDir);//rl is opened here
-         if (openfailed)
-           {
-             //Error("ReadNext","Error Occured while opening directory number %d",fCurrentDir);
-             fCurrentDir++;
-             continue;
-           }
-         fCurrentEvent = 0;
-       }
-      //Tree must exist because OpenFile would reuturn error in the other case
-      if ( fCurrentEvent >= fTree->GetEntries() )
-       {
-         delete fTree;
-         fTree = 0x0;
-         delete fFile;
-         fFile = 0x0;
-         
-         delete fSimBuffer;
-         delete fRecBuffer;
-         
-         fSimBuffer = 0x0;
-         fRecBuffer = 0x0;
-         fCurrentDir++;
-         continue;
-       }
-      
-      Info("ReadNext","Getting event %d",fCurrentEvent);
-      fTree->GetEvent(fCurrentEvent);
-      Info("ReadNext","Getting event %d Done",fCurrentEvent);
-      
-      Int_t retval = 0;
-      if (fReadRec && fReadSim)
-       {
-         retval = ReadRecAndSim();
-       }
-      else
-       {
-         if (fReadRec) retval = ReadRec();
-         if (fReadSim) retval = ReadSim();
-       } 
-
-      fCurrentEvent++;
-      if (retval != 0) 
-        {
-          //something wrong has happend during reading this event, take next
-          continue;
-        }
-
-      fNEventsRead++;
-      return retval;//success -> read one event
-      
-    }while(fCurrentDir < GetNumberOfDirs());//end of loop over directories specified in fDirs Obj Array  
-   
-  return 1; //no more directories to read
-  
-  
-}
-/********************************************************************/
-
-Int_t AliReaderAOD::ReadRecAndSim()
-{
-//Reads raconstructed and simulated data 
-
- Info("ReadRecAndSim","Found %d reconstructed tracks and %d simulated particles",
-       fRecBuffer->GetNumberOfParticles(),fSimBuffer->GetNumberOfParticles());
-
- if (fCuts->GetEntriesFast() == 0x0)
-  {//if there is no cuts we return pointer to the buffer
-    if (fEventRec != fRecBuffer)
-     {
-       delete fEventRec;
-       delete fEventSim;
-     }
-    fEventRec = fRecBuffer;//fEventRec is the pointer that the user gets when he asks about an event
-    fEventSim = fSimBuffer;
-  }
- else
-  {//if there are cuts specified
-    if ( (fEventRec == 0x0) || (fEventRec == fRecBuffer) )
-     {//we need to create a new event, if it is not existing  or it is the same as branch buffer
-       fEventRec = new AliAOD();
-       fEventSim = new AliAOD();
-
-       fEventRec->SetParticleClass( fRecBuffer->GetParticleClass() );
-       fEventSim->SetParticleClass( fSimBuffer->GetParticleClass() );
-     } 
-    else
-     {//or simply reset it in case it already exists
-       fEventRec->Reset();
-       fEventSim->Reset();
-     }
-
-    Int_t npart = fRecBuffer->GetNumberOfParticles();
-    
-    if (npart != fSimBuffer->GetNumberOfParticles())
-     {
-       Error("ReadRecAndSim","There is different number of simulated and reconstructed particles!",
-                              fSimBuffer->GetNumberOfParticles(),npart);
-       return 1;
-     } 
-    for (Int_t i = 0; i < npart; i++)
-     {
-       AliVAODParticle* prec = fRecBuffer->GetParticle(i);
-       AliVAODParticle* psim = fSimBuffer->GetParticle(i);
-       
-       if (prec == 0x0)
-        {
-          Error("ReadRecAndSim","Reconstructed Particle is NULL !!!");
-          continue;
-        }
-       if (psim == 0x0)
-        {
-          Error("ReadRecAndSim","Simulated Particle is NULL !!!");
-          continue;
-        }
-       
-       if (Rejected(prec)) continue;//we make cuts only on reconstructed data
-       
-       fEventRec->AddParticle(prec);
-       fEventSim->AddParticle( fSimBuffer->GetParticle(i));
-     }
-  }
-
- Info("ReadRecAndSim","Read %d reconstructed tracks and %d simulated particles",
-       fEventRec->GetNumberOfParticles(),fEventSim->GetNumberOfParticles());
- fTrackCounter->Fill(fEventRec->GetNumberOfParticles());
- return 0;
-}
-/********************************************************************/
-
-Int_t AliReaderAOD::ReadRec()
-{
-//Reads reconstructed data only
-
- Info("ReadRec","Found %d reconstructed tracks",fRecBuffer->GetNumberOfParticles());
-
- if (fCuts->GetEntriesFast() == 0x0)
-  {//if there is no cuts we return pointer to the buffer
-    if (fEventRec != fRecBuffer)
-     {
-       delete fEventRec;
-     }
-    fEventRec = fRecBuffer;//fEventRec is the pointer that the user gets when he asks about an event
-  }
- else
-  {//if there are cuts specified
-    if ( (fEventRec == 0x0) || (fEventRec == fRecBuffer) )
-     {//we need to create a new event, if it is not existing  or it is the same as branch buffer
-       fEventRec = new AliAOD();
-
-       fEventRec->SetParticleClass( fRecBuffer->GetParticleClass() );
-     } 
-    else
-     {//or simply reset it in case it already exists
-       fEventRec->Reset();
-     }
-
-    Int_t npart = fRecBuffer->GetNumberOfParticles();
-    for (Int_t i = 0; i < npart; i++)
-     {
-       AliVAODParticle* prec = fRecBuffer->GetParticle(i);
-       if (Rejected(prec)) continue;//we make cuts only on simulated data
-
-       fEventRec->AddParticle(prec);
-     }
-  }
-
- Info("ReadRec","Read %d reconstructed tracks",fEventRec->GetNumberOfParticles());
- fTrackCounter->Fill(fEventRec->GetNumberOfParticles());
-
- return 0;
-}
-/********************************************************************/
-
-Int_t AliReaderAOD::ReadSim()
-{
-//Reads simulated data only
-
- Info("ReadSim","Found %d simulated particles",fSimBuffer->GetNumberOfParticles());
-
- if (fCuts->GetEntriesFast() == 0x0)
-  {//if there is no cuts we return pointer to the buffer
-    if (fEventSim != fSimBuffer)
-     {
-       delete fEventSim;
-     }
-    fEventSim = fSimBuffer;
-  }
- else
-  {//if there are cuts specified
-    if ( (fEventSim == 0x0) || (fEventSim == fSimBuffer) )
-     {//we need to create a new event, if it is not existing  or it is the same as branch buffer
-       fEventSim = new AliAOD();
-
-       fEventSim->SetParticleClass( fSimBuffer->GetParticleClass() );
-     } 
-    else
-     {//or simply reset it in case it already exists
-       fEventSim->Reset();
-     }
-
-    Int_t npart = fSimBuffer->GetNumberOfParticles();
-    for (Int_t i = 0; i < npart; i++)
-     {
-       AliVAODParticle* prec = fSimBuffer->GetParticle(i);
-       if (Rejected(prec)) continue;//we make cuts only on simulated data
-       fEventSim->AddParticle(prec);
-     }
-  }
-
- Info("ReadSim","Read %d simulated particles",fEventSim->GetNumberOfParticles());
- fTrackCounter->Fill(fEventSim->GetNumberOfParticles());
-
-
- return 0;
-}
-/********************************************************************/
-
-Int_t AliReaderAOD::OpenFile(Int_t n)
-{
-//opens fFile with  tree
-
-// Info("ReadNext","Opening File %d",n);
- const TString dirname = GetDirName(n);
- if (dirname == "")
-  {
-    AliDebug(3,"Got empty string as a directory name."); 
-    return 1;
-  }
- TString filename = dirname +"/"+ fFileName;
- fFile = TFile::Open(filename.Data()); 
- if ( fFile == 0x0)
-  {
-    Error("OpenFile","Can't open fFile %s",filename.Data());
-    return 2;
-  }
- if (!fFile->IsOpen())
-  {
-    Error("OpenFile","Can't open fFile  %s",filename.Data());
-    delete fFile;
-    fFile = 0x0;
-    return 3;
-  }
-
- Info("ReadNext","File %s Is Opened, Getting the TREE",filename.Data());
- fTree = dynamic_cast<TTree*>(fFile->Get(fgkTreeName));
- if (fTree == 0x0)
-  {
-    AliDebug(3,Form("Can not find TTree object named %s",fgkTreeName.Data()));
-    delete fFile;
-    fFile = 0x0;
-    return 4;
-  }
-
-//  Info("ReadNext","Got TREE, Setting branch addresses");
-
-  if (fReadRec)
-   {
-     TBranch* branch = fTree->GetBranch(fgkReconstructedDataBranchName);
-     if (branch == 0x0)
-      {
-        Error("OpenFile","Can not find branch %s in file %s",
-              fgkReconstructedDataBranchName.Data(),filename.Data());
-        
-        delete fTree;
-        fTree = 0x0;
-        delete fFile;
-        fFile = 0x0;
-        return 5;
-      }
-     fTree->SetBranchAddress(fgkReconstructedDataBranchName,&fRecBuffer);
-   }
-  
-
-  if (fReadSim)
-   {
-     TBranch* branch = fTree->GetBranch(fgkSimulatedDataBranchName);
-     if (branch == 0x0)
-      {
-        Error("OpenFile","Can not find branch %s in file %s",
-              fgkSimulatedDataBranchName.Data(),filename.Data());
-        
-        delete fTree;
-        fTree = 0x0;
-        delete fFile;
-        fFile = 0x0;
-        return 6;
-      }
-     fTree->SetBranchAddress(fgkSimulatedDataBranchName,&fSimBuffer);
-   }
-//  Info("ReadNext","Got TREE, Addresses are set.");
-//  Info("ReadNext","Quitting the method.");
-  
-  return 0;
-}
-/********************************************************************/
-
-Int_t AliReaderAOD::WriteAOD(AliReader* reader, const char* outfilename, const char* pclassname,  Bool_t /*multcheck*/)
-{
-//reads tracks from runs and writes them to file
-  ::Info("AliReaderAOD::Write","________________________________________________________");
-  ::Info("AliReaderAOD::Write","________________________________________________________");
-  ::Info("AliReaderAOD::Write","________________________________________________________");
-  
-  if (reader == 0x0)
-   {
-     ::Error("AliReaderAOD::Write","Input Reader is NULL");
-     return -1;
-   }
-  TFile *outfile = TFile::Open(outfilename,"recreate");
-  if (outfile == 0x0)
-   {
-     ::Error("AliReaderAOD::Write","Can not open output file %s",outfilename);
-     return -1;
-   }
-
-  TTree *tree = new TTree(fgkTreeName,"Tree with tracks");
-  
-  TBranch *recbranch = 0x0, *simbranch = 0x0;
-  
-  AliAOD* eventrec = new AliAOD();//must be created before Branch is called. Otherwise clones array is not splitted
-  AliAOD* eventsim = new AliAOD();//AOD together with fParticles clones array knowing exact type of particles
-  
-  eventrec->SetParticleClassName(pclassname);
-  eventsim->SetParticleClassName(pclassname);
-  AliAOD* recbuffer = eventrec;
-  AliAOD* simbuffer = eventsim;
-  
-  if (reader->ReadsRec()) recbranch = tree->Branch(fgkReconstructedDataBranchName,"AliAOD",&recbuffer,32000,99);
-  if (reader->ReadsSim()) simbranch = tree->Branch(fgkSimulatedDataBranchName,"AliAOD",&simbuffer,32000,99);
-
-  reader->Rewind();
-  while (reader->Next() == kFALSE)
-   {
-     
-     if (reader->ReadsRec())
-      {//here we can get AOD that has different particle type
-        AliAOD* event = reader->GetEventRec();
-        if ( eventrec->GetParticleClass() != event->GetParticleClass() )
-         {//if class type is not what what we whant we copy particles
-           eventrec->CopyData(event);
-           recbuffer = eventrec;
-         }
-        else
-         {//else just pointer to event from input reader is passed
-           recbuffer = event;
-         } 
-      }
-
-     if (reader->ReadsSim())
-      {
-        AliAOD* event = reader->GetEventSim();
-        if ( eventsim->GetParticleClass() != event->GetParticleClass() )
-         {//if class type is not what what we whant we copy particles
-           eventsim->CopyData(event);
-           simbuffer = eventrec;
-         }
-        else
-         {//else just pointer to event from input reader is passed
-           simbuffer = event;
-         } 
-      }
-     tree->Fill();
-   }
-  
-  ::Info("AliReaderAOD::Write","Written %d events",tree->GetEntries());
-  outfile->cd();
-  tree->Write();
-
-  delete eventsim;
-  delete eventrec;
-  
-  delete tree;
-  delete outfile;
-  return 0; 
-}
-
diff --git a/ANALYSIS/AliReaderESD.cxx b/ANALYSIS/AliReaderESD.cxx
deleted file mode 100644 (file)
index b6aa2df..0000000
+++ /dev/null
@@ -1,869 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-//____________________________________________________________________
-//////////////////////////////////////////////////////////////////////
-//                                                                  //
-// class AliReaderESD                                               //
-//                                                                  //
-// reader for ALICE Event Summary Data (ESD).                       //
-//                                                                  //
-// Piotr.Skowronski@cern.ch                                         //
-//                                                                  //
-//////////////////////////////////////////////////////////////////////
-
-#include <TFile.h>
-#include <TGliteXmlEventlist.h>
-#include <TH1.h>
-#include <TPDGCode.h>
-#include <TParticle.h>
-#include <TString.h>
-
-#include "AliAOD.h"
-#include "AliAODParticle.h"
-#include "AliClusterMap.h"
-#include "AliESD.h"
-#include "AliESDtrack.h"
-#include "AliLog.h"
-#include "AliReaderESD.h"
-#include "AliRunLoader.h"
-#include "AliStack.h"
-
-ClassImp(AliReaderESD)
-
-AliReaderESD::AliReaderESD(const Char_t* esdfilename, const Char_t* galfilename):
- fESDFileName(esdfilename),
- fGAlFileName(galfilename),
- fFile(0x0),
- fRunLoader(0x0),
- fKeyIterator(0x0),
- fReadSim(kFALSE),
- fCheckParticlePID(kFALSE),
- fReadMostProbableOnly(kFALSE),
- fNTrackPoints(0),
- fdR(0.0),
- fClusterMap(kFALSE),
- fITSTrackPoints(kFALSE),
- fITSTrackPointsType(AliTrackPoints::kITS),
- fMustTPC(kFALSE),
- fReadCentralBarrel(kTRUE),
- fReadMuon(kFALSE),
- fReadPHOS(kFALSE),
- fNTPCClustMin(0),
- fNTPCClustMax(1500),
- fTPCChi2PerClustMin(0.0),
- fTPCChi2PerClustMax(10e5),
- fChi2Min(0.0),
- fChi2Max(10e5),
- fC00Min(0.0),
- fC00Max(10e5),
- fC11Min(0.0),
- fC11Max(10e5),
- fC22Min(0.0),
- fC22Max(10e5),
- fC33Min(0.0),
- fC33Max(10e5),
- fC44Min(0.0),
- fC44Max(10e5),
- fTPCC00Min(0.0),
- fTPCC00Max(10e5),
- fTPCC11Min(0.0),
- fTPCC11Max(10e5),
- fTPCC22Min(0.0),
- fTPCC22Max(10e5),
- fTPCC33Min(0.0),
- fTPCC33Max(10e5),
- fTPCC44Min(0.0),
- fTPCC44Max(10e5)
-
-{
-  //cosntructor
-  if ( ((Int_t)kNSpecies) != ((Int_t)AliPID::kSPECIES))
-    Fatal("AliReaderESD","ESD defintions probobly changed. Ask Youra.");
-}
-/********************************************************************/
-  
-AliReaderESD::AliReaderESD(TObjArray* dirs,const Char_t* esdfilename, const Char_t* galfilename):
- AliReader(dirs), 
- fESDFileName(esdfilename),
- fGAlFileName(galfilename),
- fFile(0x0),
- fRunLoader(0x0),
- fKeyIterator(0x0),
- fReadSim(kFALSE),
- fCheckParticlePID(kFALSE),
- fReadMostProbableOnly(kFALSE),
- fNTrackPoints(0),
- fdR(0.0),
- fClusterMap(kFALSE),
- fITSTrackPoints(kFALSE),
- fITSTrackPointsType(AliTrackPoints::kITS),
- fMustTPC(kFALSE),
- fReadCentralBarrel(kTRUE),
- fReadMuon(kFALSE),
- fReadPHOS(kFALSE),
- fNTPCClustMin(0),
- fNTPCClustMax(150),
- fTPCChi2PerClustMin(0.0),
- fTPCChi2PerClustMax(10e5),
- fChi2Min(0.0),
- fChi2Max(10e5),
- fC00Min(0.0),
- fC00Max(10e5),
- fC11Min(0.0),
- fC11Max(10e5),
- fC22Min(0.0),
- fC22Max(10e5),
- fC33Min(0.0),
- fC33Max(10e5),
- fC44Min(0.0),
- fC44Max(10e5),
- fTPCC00Min(0.0),
- fTPCC00Max(10e5),
- fTPCC11Min(0.0),
- fTPCC11Max(10e5),
- fTPCC22Min(0.0),
- fTPCC22Max(10e5),
- fTPCC33Min(0.0),
- fTPCC33Max(10e5),
- fTPCC44Min(0.0),
- fTPCC44Max(10e5)
-{
-  //cosntructor
-  if ( ((Int_t)kNSpecies) != ((Int_t)AliPID::kSPECIES))
-    Fatal("AliReaderESD","ESD defintions probobly changed. Ask Youra.");
-}
-/********************************************************************/
-
-AliReaderESD::~AliReaderESD()
-{
- //desctructor
-    delete fRunLoader;
-    delete fKeyIterator;
-    delete fFile;
-}
-
-/**********************************************************/
-Int_t AliReaderESD::ReadNext()
-{
-//reads next event from fFile
-  //fRunLoader is for reading Kine
-  
-  AliDebug(1,"Entered");
-    
-  if (fEventSim == 0x0)  fEventSim = new AliAOD();
-  if (fEventRec == 0x0)  fEventRec = new AliAOD();
-  
-  fEventSim->Reset();
-  fEventRec->Reset();
-        
-  do  //do{}while; is OK even if 0 dirs specified. In that case we try to read from "./"
-    {
-      if (fFile == 0x0)
-       {
-         fFile = OpenFile(fCurrentDir);//rl is opened here
-         if (fFile == 0x0)
-           {
-             Error("ReadNext","Cannot get fFile for dir no. %d",fCurrentDir);
-             fCurrentDir++;
-             continue;
-           }
-         fCurrentEvent = 0;
-       }
-     TString esdname = "ESD";
-     esdname+=fCurrentEvent;
-     AliESD* esd = dynamic_cast<AliESD*>(fFile->Get(esdname));
-     if (esd == 0x0)
-      {
-        AliDebug(3,Form("Can not find AliESD object named %s",esdname.Data()));
-        fCurrentDir++;
-        delete fFile;//we have to assume there is no more ESD objects in the fFile
-        fFile = 0x0;
-        delete fRunLoader;
-        fRunLoader = 0x0;
-        continue;
-      }
-      ReadESD(esd);
-      
-      fCurrentEvent++;
-      fNEventsRead++;
-      delete esd;
-      return 0;//success -> read one event
-    }while(fCurrentDir < GetNumberOfDirs());//end of loop over directories specified in fDirs Obj Array  
-   
-  return 1; //no more directories to read
-}
-
-/**********************************************************/
-Int_t AliReaderESD::ReadESD(AliESD* esd)
-{
-//Reads esd data
-  if (esd == 0x0)
-   {
-     Error("ReadESD","ESD is NULL");
-     return 1;
-   }
-  
-  // seperate each method
-  if (fReadCentralBarrel) ReadESDCentral(esd);
-
-  if (fReadMuon) ReadESDMuon(esd);
-
-  if (fReadPHOS) ReadESDPHOS(esd);
-
-  return 1;
-}
-
-/**********************************************************/
-Int_t AliReaderESD::ReadESDCentral(AliESD* esd)
-{
-  //****** Tentative particle type "concentrations"
-  static const Double_t kConcentr[5]={0.05, 0., 0.85, 0.10, 0.05};
-  
-  Double_t pidtable[kNSpecies];//array used for reading pid probabilities from ESD track
-  Double_t w[kNSpecies];
-  Double_t mom[3];//momentum
-  Double_t pos[3];//position
-  Double_t vertexpos[3];//vertex position
-  //Reads one ESD
-
-  TDatabasePDG* pdgdb = TDatabasePDG::Instance();
-  if (pdgdb == 0x0)
-   {
-     Error("ReadESD","Can not get PDG Database Instance.");
-     return 1;
-   }
-   
-  Float_t mf = esd->GetMagneticField()/10.; //AliESD::GetMagnField returns mf in kG
-
-  if ( (mf == 0.0) && ((fNTrackPoints > 0) || fITSTrackPoints) )
-   {
-      Error("ReadESD","Magnetic Field is 0 and Track Points Demended. Skipping to next event.");
-
-   }
-
-  if (fITSTrackPoints)
-   {
-     Info("ReadESD","Magnetic Field is %f",mf);
-     //AliKalmanTrack::SetMagneticField(mf);
-   }
-  AliStack* stack = 0x0;
-  if (fReadSim && fRunLoader)
-   {
-     fRunLoader->GetEvent(fCurrentEvent);
-     stack = fRunLoader->Stack();
-   }
-
-  const AliESDVertex* vertex = esd->GetVertex();
-  if (vertex == 0x0)
-   {
-     Info("ReadESD","ESD returned NULL pointer to vertex - assuming (0.0,0.0,0.0)");
-     vertexpos[0] = 0.0;
-     vertexpos[1] = 0.0;
-     vertexpos[2] = 0.0;
-   }
-  else
-   {
-     vertex->GetXYZ(vertexpos);
-   }
-   
-  AliDebug(1,Form("Primary Vertex is (%f,%f,%f)",vertexpos[0],vertexpos[1],vertexpos[2]));
-   
-  Info("ReadESD","Reading Event %d",fCurrentEvent);
-
-  Int_t ntr = esd->GetNumberOfTracks();
-  Info("ReadESD","Found %d tracks.",ntr);
-  for (Int_t i = 0;i<ntr; i++)
-   {
-     AliESDtrack *esdtrack = esd->GetTrack(i);
-     if (esdtrack == 0x0)
-      {
-        Error("Next","Can not get track %d", i);
-        continue;
-      }
-
-     //if (esdtrack->HasVertexParameters() == kFALSE) 
-     if ((esdtrack->GetStatus() & AliESDtrack::kITSrefit) == kFALSE)
-      {
-        AliDebug(3,Form("Particle skipped: Data at vertex not available."));
-        continue;
-      }
-
-     if (fMustTPC)
-      {
-       if ((esdtrack->GetStatus() & AliESDtrack::kTPCin) == kFALSE)
-        {
-          AliDebug(3,"Particle skipped: Was not reconstructed in TPC.");
-          continue;
-        }
-      }     
-
-     if ((esdtrack->GetStatus() & AliESDtrack::kESDpid) == kFALSE) 
-      {
-        AliDebug(3,"Particle skipped: PID BIT is not set.");
-        continue;
-      }
-
-
-     Double_t alpha,extx;
-     Double_t extp[5];
-     esdtrack->GetConstrainedExternalParameters(alpha,extx,extp);
-     if (extp[4] == 0.0)
-      {
-        AliDebug(3,"Track has 0 contrianed curvature -> Probobly parameters never updated. Skipping.");
-        continue;
-      } 
-     esdtrack->GetESDpid(pidtable);
-     esdtrack->GetConstrainedPxPyPz(mom);
-     esdtrack->GetConstrainedXYZ(pos);
-     pos[0] -= vertexpos[0];//we are interested only in relative position to Primary vertex at this point
-     pos[1] -= vertexpos[1];
-     pos[2] -= vertexpos[2];
-
-     Int_t charge = (extp[4] > 0)?1:-1;//if curvature=charg/Pt is positive charge is positive
-
-     //Particle from kinematics
-     AliAODParticle* particle = 0;
-     Bool_t keeppart = kFALSE;
-     if ( fReadSim && stack  )
-      {
-        if (esdtrack->GetLabel() < 0) continue;//this is fake -  we are not able to match any track 
-        TParticle *p = stack->Particle(esdtrack->GetLabel());
-        if (p==0x0) 
-         {
-           Error("ReadNext","Can not find track with such label.");
-           continue;
-         }
-         
-        if (fCheckParticlePID)
-         {
-           if(Rejected(p->GetPdgCode())) 
-            {
-              AliDebug(6,Form("Simulated Particle PID (%d) did not pass the cut.",p->GetPdgCode()));
-              continue; //check if we are intersted with particles of this type 
-            }
-         }  
-//           if(p->GetPdgCode()<0) charge = -1;
-        particle = new AliAODParticle(*p,i);
-
-      }
-      
-     if(CheckTrack(esdtrack)) continue;
-      
-     //Here we apply Bayes' formula
-     Double_t rc=0.;
-     for (Int_t s=0; s<AliPID::kSPECIES; s++) rc+=kConcentr[s]*pidtable[s];
-     if (rc==0.0) 
-      {
-        AliDebug(3,"Particle rejected since total bayessian PID probab. is zero.");
-        continue;
-      }
-
-     for (Int_t s=0; s<AliPID::kSPECIES; s++) w[s]=kConcentr[s]*pidtable[s]/rc;
-
-     if (AliDebugLevel() > 4)
-      { 
-        Info("ReadNext","###########################################################################");
-        Info("ReadNext","Momentum: %f %f %f",mom[0],mom[1],mom[2]);
-        Info("ReadNext","Position: %f %f %f",pos[0],pos[1],pos[2]);
-        TString msg("Pid list got from track:");
-        for (Int_t s = 0;s<kNSpecies;s++)
-         {
-           msg+="\n    ";
-           msg+=s;
-           msg+="(";
-           msg+=charge*GetSpeciesPdgCode((ESpecies)s);
-           msg+="): ";
-           msg+=w[s];
-           msg+=" (";
-           msg+=pidtable[s];
-           msg+=")";
-         }
-        Info("ReadNext","%s",msg.Data());
-      }//if (AliDebugLevel()>4)
-
-      AliTrackPoints* tpts = 0x0;
-      if (fNTrackPoints > 0) 
-       {
-         tpts = new AliTrackPoints(fNTrackPoints,esdtrack,mf*10.0,fdR);
-//         tpts->Move(-vertexpos[0],-vertexpos[1],-vertexpos[2]);
-       }
-
-      AliTrackPoints* itstpts = 0x0;
-      if (fITSTrackPoints) 
-       {
-         itstpts = new AliTrackPoints(fITSTrackPointsType,esdtrack,mf*10.0);
-//         itstpts->Move(-vertexpos[0],-vertexpos[1],-vertexpos[2]);
-       }
-
-      AliClusterMap* cmap = 0x0; 
-      if (  fClusterMap ) 
-       {
-         cmap = new AliClusterMap(esdtrack);
-       }
-     
-     //If this flag fReadMostProbableOnly is false the 
-     //loop over species (see "LOOPPIDS") is over all possible PIDs
-     //in other case the most probablle PID is searched
-     //and the loop is limited to that PID only
-
-     Int_t firstspecie = 0;
-     Int_t lastspecie = kNSpecies;
-     
-     if (fReadMostProbableOnly)
-      { 
-        //find the most probable PID
-        Int_t spec = 0;
-        Float_t maxprob = w[0];
-        for (Int_t s=1; s<AliPID::kSPECIES; s++) 
-         {
-           if (w[s]>maxprob)
-            {
-              maxprob = w[s];
-              spec = s;
-            }
-         }
-        firstspecie = spec;
-        lastspecie = spec + 1;
-      }
-     
-     for (Int_t s = firstspecie; s<lastspecie; s++)//LOOPPIDS
-      {
-        Int_t pdgcode = charge*GetSpeciesPdgCode((ESpecies)s);
-        Float_t pp = w[s];
-        if (pp == 0.0) 
-         {
-           AliDebug(6,Form("Probability of being PID %d is zero. Continuing.",pdgcode));
-           continue;
-         }
-
-        if(Rejected(pdgcode)) 
-         {
-           AliDebug(6,Form("PID (%d) did not pass the cut.",pdgcode));
-           continue; //check if we are intersted with particles of this type 
-         }
-
-        Double_t mass = pdgdb->GetParticle(pdgcode)->Mass();
-        Double_t tEtot = TMath::Sqrt( mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2] + mass*mass);//total energy of the track
-
-        AliAODParticle* track = new AliAODParticle(pdgcode, w[s],i, 
-                                                   mom[0], mom[1], mom[2], tEtot,
-                                                   pos[0], pos[1], pos[2], 0.);
-        //copy probabilitis of other species (if not zero)
-        for (Int_t k = 0; k<kNSpecies; k++)
-         {
-           if (k == s) continue;
-           if (w[k] == 0.0) continue;
-           track->SetPIDprobability(charge*GetSpeciesPdgCode( (ESpecies)k ),w[k]);
-         }
-
-        if(Rejected(track))//check if meets all criteria of any of our cuts
-                       //if it does not delete it and take next good track
-         { 
-           AliDebug(5,"Track did not pass the cut");
-           delete track;
-           continue;
-         }
-
-        //Single Particle cuts on cluster map and track points rather do not have sense
-        if (tpts)
-         {
-           track->SetTPCTrackPoints(tpts);
-         }
-         
-        if (itstpts)
-         {
-           track->SetITSTrackPoints(itstpts); 
-         }
-
-        if (cmap) 
-         { 
-           track->SetClusterMap(cmap);
-         }
-
-        fEventRec->AddParticle(track);
-        if (particle) fEventSim->AddParticle(particle);
-        keeppart = kTRUE;
-
-        if (AliDebugLevel() > 4 )
-         {
-           Info("ReadNext","\n\nAdding Particle with incarnation %d",pdgcode);
-           track->Print();
-           if (particle) particle->Print();
-           Info("ReadNext","\n----------------------------------------------\n");
-         }
-      }//for (Int_t s = 0; s<kNSpecies; s++)
-
-     if (keeppart == kFALSE) 
-      {
-        delete particle;//particle was not stored in event
-        delete tpts;
-        delete itstpts;
-        delete cmap;
-      }
-     else
-      {
-        if ( fReadSim && stack  )
-         {
-           if (particle->P() < 0.00001)
-            {
-              Info("ReadNext","###################################");
-              Info("ReadNext","###################################");
-              Info("ReadNext","Track Label %d",esdtrack->GetLabel());
-              TParticle *p = stack->Particle(esdtrack->GetLabel());
-              Info("ReadNext","");
-              p->Print();
-              Info("ReadNext","");
-              particle->Print();
-            }
-         }   
-      } 
-
-   }//for (Int_t i = 0;i<ntr; i++)  -- loop over tracks
-
-  Info("ReadNext","Read %d tracks and %d particles from event %d (event %d in dir %d).",
-         fEventRec->GetNumberOfParticles(), fEventSim->GetNumberOfParticles(),
-         fNEventsRead,fCurrentEvent,fCurrentDir);
-  fTrackCounter->Fill(fEventRec->GetNumberOfParticles());
-  
-  /******************************************************/
-  /******     Setting glevet properties     *************/
-  /******************************************************/
-    
-  if (fEventRec->GetNumberOfParticles() > 0)
-   {
-     fEventRec->SetPrimaryVertex(vertexpos[0],vertexpos[1],vertexpos[2]);
-   }
-  return 0;
-}
-
-/**********************************************************/
-Int_t AliReaderESD::ReadESDMuon(AliESD* esd)
-{
-  // Reads the muon tracks from the ESD
-  Double_t vertexpos[3];//vertex position, assuming no secondary decay
-
-  const AliESDVertex* vertex = esd->GetVertex();
-
-  if (vertex == 0x0) {
-    Info("ReadESD","ESD returned NULL pointer to vertex - assuming (0.0,0.0,0.0)");
-    vertexpos[0] = 0.0;
-    vertexpos[1] = 0.0;
-    vertexpos[2] = 0.0;
-  } else {
-    vertex->GetXYZ(vertexpos);
-  }
-
- Int_t nTracks = (Int_t)esd->GetNumberOfMuonTracks() ;
-
- AliDebug(1,Form("Reading Event %d \nFound %d tracks.",fCurrentEvent,nTracks));
-
- // settings
-  Float_t chi2Cut = 100.;
-  Float_t ptCutMin = 1.;
-  Float_t ptCutMax = 10000.;
-  Float_t muonMass = 0.105658389;
-  Int_t pdgcode = -13;
-  Double_t thetaX, thetaY, pYZ;
-  Double_t pxRec1, pyRec1, pzRec1, e1;
-  Int_t charge;
-
-  Int_t ntrackhits;
-  Double_t fitfmin;
-
-  TLorentzVector fV1;
-  fEventRec->Reset();
-  for (Int_t iTrack = 0; iTrack <  nTracks;  iTrack++) {
-
-      AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
-
-      thetaX = muonTrack->GetThetaX();
-      thetaY = muonTrack->GetThetaY();
-
-      pYZ     =  1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
-      pzRec1  = - pYZ / TMath::Sqrt(1.0 + TMath::Tan(thetaY)*TMath::Tan(thetaX));
-      pxRec1  = pzRec1 * TMath::Tan(thetaX);
-      pyRec1  = pzRec1 * TMath::Tan(thetaY);
-      charge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
-      e1 = TMath::Sqrt(muonMass * muonMass + pxRec1 * pxRec1 + pyRec1 * pyRec1 + pzRec1 * pzRec1);
-      fV1.SetPxPyPzE(pxRec1, pyRec1, pzRec1, e1);
-
-      ntrackhits = muonTrack->GetNHit();
-      fitfmin    = muonTrack->GetChi2();
-
-      // transverse momentum
-      Float_t pt1 = fV1.Pt();
-
-      // chi2 per d.o.f.
-      Float_t ch1 =  fitfmin / (2.0 * ntrackhits - 5);
-
-      if ((ch1 < chi2Cut) && (pt1 > ptCutMin) && (pt1 < ptCutMax)) {
-       AliAODParticle* track = new AliAODParticle(pdgcode*charge,1,iTrack, 
-                                                   pxRec1, pyRec1,pzRec1, e1,
-                                                   vertexpos[0], vertexpos[1], vertexpos[2], 0.);
-        fEventRec->AddParticle(track);
-      }
-  }
-  fTrackCounter->Fill(fEventRec->GetNumberOfParticles());
-  return 0;
-}
-
-/**********************************************************/
-
-void AliReaderESD::Rewind()
-{
-  //rewinds reading 
-  //  delete fKeyIterator;
-  delete fFile;
-  fFile = 0x0;
-  // fKeyIterator = 0x0;
-  delete fRunLoader;
-  fRunLoader = 0x0;
-  fCurrentDir = 0;
-  fNEventsRead = 0;
-  if (fEventList) fEventList->Reset(); 
-  if (fTrackCounter) fTrackCounter->Reset();
-}
-/**********************************************************/
-
-TFile* AliReaderESD::OpenFile(Int_t n)
-{
-//opens fFile with  tree
- if (fEventList)
-  { 
-    if (fCurrentDir > n)
-     {
-       fEventList->Reset();
-       fCurrentDir = 0;
-     }
-    
-    while (fCurrentDir < n)
-     {
-       fEventList->Next();
-       fCurrentDir++;
-     }
-    fEventList->Next();
-  }
- const TString& dirname = GetDirName(n);
- if (dirname == "")
-  {
-   Error("OpenFiles","Can not get directory name");
-   return 0x0;
-  }
- TString filename;
- if (fEventList)
-  {
-    filename = fEventList->GetURL(fESDFileName);
-  }
- else
-  {
-    filename = dirname +"/"+ fESDFileName;
-  }
- Info("OpenFile","%s ==> %s",fESDFileName.Data(),filename.Data()); 
- TFile *ret = TFile::Open(filename.Data()); 
-
- if ( ret == 0x0)
-  {
-    Error("OpenFiles","Can't open fFile %s",filename.Data());
-    return 0x0;
-  }
- if (!ret->IsOpen())
-  {
-    Error("OpenFiles","Can't open fFile  %s",filename.Data());
-    return 0x0;
-  }
- if (fReadSim )
-  {
-    TString gafilename;
-    if (fEventList)
-     {
-       gafilename = fEventList->GetURL(fGAlFileName);
-     }
-    else
-     {
-       gafilename = dirname +"/"+ fGAlFileName;
-     }
-   Info("OpenFile","%s ==> %s",fGAlFileName.Data(),gafilename.Data()); 
-
-   fRunLoader = AliRunLoader::Open(gafilename);
-   
-   if (fRunLoader == 0x0)
-    {
-      Error("OpenFiles","Can't get RunLoader for directory %s",dirname.Data());
-      delete ret;
-      return 0x0;
-    }
-    
-   fRunLoader->LoadHeader();
-   
-   if (fEventList)
-    {
-      TString kinefilename = fEventList->GetURL("Kinematics.root");
-      fRunLoader->SetKineFileName(kinefilename);
-      Info("OpenFile","%s ==> %s","Kinematics.root",kinefilename.Data()); 
-    } 
-   
-   if (fRunLoader->LoadKinematics())
-    {
-      Error("Next","Error occured while loading kinematics.");
-      delete fRunLoader;
-      delete ret;
-      return 0x0;
-    }
-  }
-   
- return ret;
-}
-/**********************************************************/
-
-Int_t AliReaderESD::GetSpeciesPdgCode(ESpecies spec)//skowron
-{
-  //returns pdg code from the PID index
-  //ask jura about charge
-  switch (spec)
-   {
-     case kESDElectron:
-       return kPositron;
-       break;
-     case kESDMuon:
-       return kMuonPlus;
-       break;
-     case kESDPion:
-       return kPiPlus;
-       break;
-     case kESDKaon:
-       return kKPlus;
-       break;
-     case kESDProton:
-       return kProton;
-       break;
-     default:
-       ::Warning("GetSpeciesPdgCode","Specie with number %d is not defined.",(Int_t)spec);
-       break;
-   }
-  return 0;
-}
-/********************************************************************/
-Bool_t AliReaderESD::CheckTrack(AliESDtrack* t) const
-{
-  //Performs check of the track
-  
-  if ( (t->GetConstrainedChi2() < fChi2Min) || (t->GetConstrainedChi2() > fChi2Max) ) return kTRUE;
-  
-  if ( (t->GetTPCclusters(0x0) < fNTPCClustMin) || (t->GetTPCclusters(0x0) > fNTPCClustMax) ) return kTRUE;
-
-  if (t->GetTPCclusters(0x0) > 0)
-   {
-     Float_t chisqpercl = t->GetTPCchi2()/((Double_t)t->GetTPCclusters(0x0));
-     if ( (chisqpercl < fTPCChi2PerClustMin) || (chisqpercl > fTPCChi2PerClustMax) ) return kTRUE;
-   }
-
-  Double_t cc[15];
-  t->GetConstrainedExternalCovariance(cc);
-
-  if ( (cc[0]  < fC00Min) || (cc[0]  > fC00Max) ) return kTRUE;
-  if ( (cc[2]  < fC11Min) || (cc[2]  > fC11Max) ) return kTRUE;
-  if ( (cc[5]  < fC22Min) || (cc[5]  > fC22Max) ) return kTRUE;
-  if ( (cc[9]  < fC33Min) || (cc[9]  > fC33Max) ) return kTRUE;
-  if ( (cc[14] < fC44Min) || (cc[14] > fC44Max) ) return kTRUE;
-
-
-  t->GetInnerExternalCovariance(cc);
-
-  if ( (cc[0]  < fTPCC00Min) || (cc[0]  > fTPCC00Max) ) return kTRUE;
-  if ( (cc[2]  < fTPCC11Min) || (cc[2]  > fTPCC11Max) ) return kTRUE;
-  if ( (cc[5]  < fTPCC22Min) || (cc[5]  > fTPCC22Max) ) return kTRUE;
-  if ( (cc[9]  < fTPCC33Min) || (cc[9]  > fTPCC33Max) ) return kTRUE;
-  if ( (cc[14] < fTPCC44Min) || (cc[14] > fTPCC44Max) ) return kTRUE;
-
-  return kFALSE;
-
-}
-/********************************************************************/
-
-void AliReaderESD::SetChi2Range(Float_t min, Float_t max)
-{
-  //sets range of Chi2 per Cluster
-  fChi2Min = min;
-  fChi2Max = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetTPCNClustersRange(Int_t min,Int_t max)
-{
- //sets range of Number Of Clusters that tracks have to have
- fNTPCClustMin = min;
- fNTPCClustMax = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetTPCChi2PerCluserRange(Float_t min, Float_t max)
-{
-  //sets range of Chi2 per Cluster
-  fTPCChi2PerClustMin = min;
-  fTPCChi2PerClustMax = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetC00Range(Float_t min, Float_t max)
-{
- //Sets range of C00 parameter of covariance matrix of the track
- //it defines uncertainty of the momentum
-  fC00Min = min;
-  fC00Max = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetC11Range(Float_t min, Float_t max)
-{
- //Sets range of C11 parameter of covariance matrix of the track
- //it defines uncertainty of the momentum
-  fC11Min = min;
-  fC11Max = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetC22Range(Float_t min, Float_t max)
-{
- //Sets range of C22 parameter of covariance matrix of the track
- //it defines uncertainty of the momentum
-  fC22Min = min;
-  fC22Max = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetC33Range(Float_t min, Float_t max)
-{
- //Sets range of C33 parameter of covariance matrix of the track
- //it defines uncertainty of the momentum
-  fC33Min = min;
-  fC33Max = max;
-}
-/********************************************************************/
-
-void AliReaderESD::SetC44Range(Float_t min, Float_t max)
-{
- //Sets range of C44 parameter of covariance matrix of the track
- //it defines uncertainty of the momentum
-  fC44Min = min;
-  fC44Max