New classes for selection of events using their tags (P.Christakoglou)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Nov 2005 09:57:34 +0000 (09:57 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Nov 2005 09:57:34 +0000 (09:57 +0000)
STEER/AliEventTagCuts.cxx [new file with mode: 0644]
STEER/AliEventTagCuts.h [new file with mode: 0644]
STEER/AliTagAnalysis.cxx [new file with mode: 0644]
STEER/AliTagAnalysis.h [new file with mode: 0644]
STEER/STEERLinkDef.h
STEER/libSTEER.pkg

diff --git a/STEER/AliEventTagCuts.cxx b/STEER/AliEventTagCuts.cxx
new file mode 100644 (file)
index 0000000..8dad5f7
--- /dev/null
@@ -0,0 +1,851 @@
+/**************************************************************************
+ * 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$ */
+
+//-----------------------------------------------------------------
+//           AliEventTagCuts class
+//   This is the class to deal with the event tag level cuts
+//   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
+//-----------------------------------------------------------------
+
+class AliLog;
+class AliESD;
+
+#include "AliEventTag.h"
+#include "AliEventTagCuts.h"
+
+ClassImp(AliEventTagCuts)
+
+
+//----------------------------------------//
+AliEventTagCuts::AliEventTagCuts()
+{
+  //Default constructor which calls the Reset method.
+  Reset();
+}
+
+//----------------------------------------//
+AliEventTagCuts::~AliEventTagCuts()
+{  
+  //Defaut destructor.
+}
+
+//----------------------------------------//
+void AliEventTagCuts::Reset()
+{
+  //Sets dummy values to every private member.
+  fVxFlag = kFALSE;
+  fVyFlag = kFALSE;
+  fVzFlag = kFALSE;
+  fParticipantsFlag = kFALSE;
+  fImpactParamFlag = kFALSE;
+  fPVFlag = kFALSE;
+  fZDCNeutronEnergyFlag = kFALSE;
+  fZDCProtonEnergyFlag = kFALSE;
+  fZDCEMEnergyFlag = kFALSE;
+  fT0VertexZFlag = kFALSE;
+  fMultFlag = kFALSE;
+  fMultPosFlag = kFALSE;
+  fMultNegFlag = kFALSE;
+  fMultNeutrFlag = kFALSE;
+  fV0sFlag = kFALSE;
+  fCascadesFlag = kFALSE;
+  fkinksFlag = kFALSE;
+  fMaxJetEnergyFlag = kFALSE;
+  fNHardPhotonsCandidatesFlag = kFALSE;
+  fMaxNeutralFlag = kFALSE;
+  fChargedAbove1GeVFlag = kFALSE;
+  fChargedAbove3GeVFlag = kFALSE;
+  fChargedAbove10GeVFlag = kFALSE;
+  fMuonsAbove1GeVFlag = kFALSE;
+  fMuonsAbove3GeVFlag = kFALSE;
+  fMuonsAbove10GeVFlag = kFALSE;
+  fElectronsAbove1GeVFlag = kFALSE;
+  fElectronsAbove3GeVFlag = kFALSE;
+  fElectronsAbove10GeVFlag = kFALSE;
+  fElectronsFlag = kFALSE;
+  fMuonsFlag = kFALSE;
+  fPionsFlag = kFALSE;
+  fKaonsFlag = kFALSE;
+  fProtonsFlag = kFALSE;
+  fLambdasFlag = kFALSE;
+  fPhotonFlag = kFALSE;
+  fPi0sFlag = kFALSE;
+  fNeutronsFlag = kFALSE;
+  fKaon0sFlag = kFALSE;
+  fTotalPFlag = kFALSE;
+  fMeanPtFlag = kFALSE;
+  fMaxPtFlag = kFALSE;
+  fTotalNeutralPFlag = kFALSE;
+  fMeanNeutralPtFlag = kFALSE;
+  fMaxNeutralPtFlag = kFALSE;
+  fEventPlaneAngleFlag = kFALSE;
+  fHBTRadiiFlag = kFALSE;
+  
+  fVxMin = -1000.0;
+  fVxMax = 1000.0; 
+  fVyMin = -1000.0;
+  fVyMax = 1000.0;  
+  fVzMin = -1000.0;
+  fVzMax = 1000.0;
+
+  fMultMin = 0;
+  fMultMax = 100000;  
+
+  fParticipantsMin = -1;
+  fParticipantMax = 10000;
+  fImpactParamMin = -1.0;
+  fImpactParamMax = 1000.0;
+  fPrimaryVertexFlag = 1;
+  fZDCNeutronEnergyMin = -1.0;
+  fZDCNeutronEnergyMax = 100000.0;
+  fZDCProtonEnergyMin = -1.0;
+  fZDCProtonEnergyMax = 100000.0;
+  fZDCEMEnergyMin = -1.0;
+  fZDCEMEnergyMax = 100000.0;
+  fT0VertexZMin = -10000.0;
+  fT0VertexZMax = 10000.0;
+  
+  fMultPosMin = -1;
+  fMultPosMax = 100000;
+  fMultNegMin = -1;
+  fMultNegMax = 100000;
+  fMultNeutrMin = -1;
+  fMultNeutrMax = 100000;
+  fV0sMin = -1;
+  fV0sMax = 1000000;
+  fCascadesMin = -1;
+  fCascadesMax = 100000;
+  fkinksMin = -1;
+  fkinksMax = 1000000;
+
+  fMaxJetEnergy = -1.0; 
+
+  fNHardPhotonsCandidatesMin = -1;
+  fNHardPhotonsCandidatesMax = 100000;
+  fMaxNeutralEnergy = -1.0; 
+  
+  fChargedAbove1GeVMin = -1;
+  fChargedAbove1GeVMax = 100000;
+  fChargedAbove3GeVMin = -1;
+  fChargedAbove3GeVMax = 100000;
+  fChargedAbove10GeVMin = -1;
+  fChargedAbove10GeVMax = 100000;
+  fMuonsAbove1GeVMin = -1;
+  fMuonsAbove1GeVMax = 100000;
+  fMuonsAbove3GeVMin = -1;
+  fMuonsAbove3GeVMax = 100000;
+  fMuonsAbove10GeVMin = -1;
+  fMuonsAbove10GeVMax = 100000; 
+  fElectronsAbove1GeVMin = -1;
+  fElectronsAbove1GeVMax = 100000;
+  fElectronsAbove3GeVMin = -1;
+  fElectronsAbove3GeVMax = 100000;
+  fElectronsAbove10GeVMin = -1;
+  fElectronsAbove10GeVMax = 100000;
+
+  fElectronsMin = -1;
+  fElectronsMax = 100000;
+  fMuonsMin = -1;
+  fMuonsMax = 100000;
+  fPionsMin = -1;
+  fPionsMax = 100000;
+  fKaonsMin = -1;
+  fKaonsMax = 100000;
+  fProtonsMin = -1;
+  fProtonsMax = 100000;
+  fLambdasMin = -1;
+  fLambdasMax = 100000;
+  fPhotonsMin = -1;
+  fPhotonsMax = 100000;
+  fPi0sMin = -1;
+  fPi0sMax = 100000; 
+  fNeutronsMin = -1;
+  fNeutronsMax = 100000; 
+  fKaon0sMin = -1;
+  fKaon0sMax = 100000; 
+
+  fTotalPMin = -1.0;
+  fTotalPMax = 1000000.0;
+  fMeanPtMin = -1.0;
+  fMeanPtMax = 100000.0;
+  fMaxPt = -1.0; 
+  fTotalNeutralPMin = -1.0;
+  fTotalNeutralPMax = 1000000.0;  
+  fMeanNeutralPtMin = -1.0;
+  fMeanNeutralPtMax = 1000000.0; 
+  fMaxNeutralPt = -1.0; 
+  fEventPlaneAngleMin = -10000000.0;
+  fEventPlaneAngleMax = 10000000.0; 
+  fHBTRadiiMin = -1.0;
+  fHBTRadiiMax = 100000.0; 
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetPrimaryVertexXRange(Float_t r1, Float_t r2)
+{
+  //Sets the primary vertex x range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fVxMin = r1;
+  fVxMax = r2; 
+  fVxFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetPrimaryVertexYRange(Float_t r1, Float_t r2)
+{
+  //Sets the primary vertex y range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fVyMin = r1;
+  fVyMax = r2; 
+  fVyFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetPrimaryVertexZRange(Float_t r1, Float_t r2)
+{
+  //Sets the primary vertex z range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fVzMin = r1;
+  fVzMax = r2; 
+  fVzFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetMultiplicityRange(Int_t n1, Int_t n2)
+{
+  //Sets the primary multiplicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMultMin = n1;
+  fMultMax = n2;
+  fMultFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetParticipantsRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of participants range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fParticipantsMin = i1;
+  fParticipantMax = i2;
+  fParticipantsFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetImpactParamRange(Float_t r1, Float_t r2)
+{
+  //Sets the impact parameter range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fImpactParamMin = r1;
+  fImpactParamMax = r2;
+  fImpactParamFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetPrimaryVertexFlag(Int_t i)
+{
+  //Sets the primary vertex flag cut 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fPrimaryVertexFlag = i;
+  fPVFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetZDCNeutrRange(Float_t r1, Float_t r2)
+{
+  //Sets the ZDC's neutron energy range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fZDCNeutronEnergyMin = r1;
+  fZDCNeutronEnergyMax = r2;
+  fZDCNeutronEnergyFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetZDCProtRange(Float_t r1, Float_t r2)
+{
+  //Sets the ZDC's proton energy range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fZDCProtonEnergyMin = r1;
+  fZDCProtonEnergyMax = r2;
+  fZDCProtonEnergyFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetZDCEMRange(Float_t r1, Float_t r2)
+{
+  //Sets the ZDC's e/m energy range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fZDCEMEnergyMin = r1;
+  fZDCEMEnergyMax = r2;
+  fZDCEMEnergyFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetT0VertexZRange(Float_t r1, Float_t r2)
+{
+  //Sets the T0's Vz range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fT0VertexZMin = r1;
+  fT0VertexZMax = r2;
+  fT0VertexZFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetPosMultiplicityRange(Int_t n1, Int_t n2)
+{
+  //Sets the positive multiplicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMultPosMin = n1;
+  fMultPosMax = n2;
+  fMultPosFlag = kTRUE;
+}
+
+
+//----------------------------------------//
+void AliEventTagCuts::SetNegMultiplicityRange(Int_t n1, Int_t n2)
+{
+  //Sets the negative multiplicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMultNegMin = n1;
+  fMultNegMax = n2;
+  fMultNegFlag = kTRUE;
+}
+
+
+//----------------------------------------//
+void AliEventTagCuts::SetNeutrMultiplicityRange(Int_t n1, Int_t n2)
+{
+  //Sets the neutral particle multiplicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMultNeutrMin = n1;
+  fMultNeutrMax = n2;
+  fMultNeutrFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetV0sRange(Int_t n1, Int_t n2)
+{
+  //Sets the v0s multiplicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fV0sMin = n1;
+  fV0sMax = n2;
+  fV0sFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetCascadesRange(Int_t n1, Int_t n2)
+{
+  //Sets the cascades multiplicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fCascadesMin = n1;
+  fCascadesMax = n2;
+  fCascadesFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetKinksRange(Int_t n1, Int_t n2)
+{
+  //Sets the kinks multipliicity range 
+  //and the corresponding flag to kTRUE if the cut is used.
+  fkinksMin = n1;
+  fkinksMax = n2;
+  fkinksFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetMaxJetEnergy(Float_t r1)
+{
+  //Sets the lower limit of the maximum jet energy
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMaxJetEnergy = r1; 
+  fMaxJetEnergyFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetMaxNeutralEnergy(Float_t r1)
+{
+  //Sets the lower limit of the maximum neutral jet energy
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMaxNeutralEnergy = r1; 
+  fMaxNeutralFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetHardPhotonsRange(Int_t i1, Int_t i2)
+{
+  //Sets the hard photons multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fNHardPhotonsCandidatesMin = i1;
+  fNHardPhotonsCandidatesMax = i2;
+  fNHardPhotonsCandidatesFlag = kTRUE;
+} 
+
+//----------------------------------------//
+void AliEventTagCuts::SetNChargedAbove1GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of charged above 1GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fChargedAbove1GeVMin = i1;
+  fChargedAbove1GeVMax = i2;
+  fChargedAbove1GeVFlag = kTRUE;
+}
+
+//----------------------------------------//
+ void AliEventTagCuts::SetNChargedAbove3GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of charged above 3GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fChargedAbove3GeVMin = i1;
+  fChargedAbove3GeVMax = i2;
+  fChargedAbove3GeVFlag = kTRUE;
+}
+
+
+//----------------------------------------//
+void AliEventTagCuts::SetNChargedAbove10GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of charged above 10GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fChargedAbove10GeVMin = i1;
+  fChargedAbove10GeVMax = i2;
+  fChargedAbove10GeVFlag = kTRUE;
+}
+
+
+//----------------------------------------//
+void AliEventTagCuts::SetNMuonsAbove1GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of muons above 1GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMuonsAbove1GeVMin = i1;
+  fMuonsAbove1GeVMax = i2;
+  fMuonsAbove1GeVFlag = kTRUE;
+}
+
+
+//----------------------------------------//
+void AliEventTagCuts::SetNMuonsAbove3GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of muons above 3GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMuonsAbove3GeVMin = i1;
+  fMuonsAbove3GeVMax = i2;
+  fMuonsAbove3GeVFlag = kTRUE;
+} 
+
+//----------------------------------------//
+void AliEventTagCuts::SetNMuonsAbove10GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of muons above 10GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMuonsAbove10GeVMin = i1;
+  fMuonsAbove10GeVMax = i2; 
+  fMuonsAbove10GeVFlag = kTRUE;
+}
+
+
+//----------------------------------------//
+void AliEventTagCuts::SetNElectronsAbove1GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of electrons above 1GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fElectronsAbove1GeVMin = i1;
+  fElectronsAbove1GeVMax = i2;
+  fElectronsAbove1GeVFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetNElectronsAbove3GeVRange(Int_t i1, Int_t i2)
+{
+  //Sets the number of electrons above 3GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fElectronsAbove3GeVMin = i1;
+  fElectronsAbove3GeVMax = i2;
+  fElectronsAbove3GeVFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetNElectronsAbove10GeVRange(Int_t i1, Int_t i2)
+{  
+  //Sets the number of electrons above 10GeV range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fElectronsAbove10GeVMin = i1;
+  fElectronsAbove10GeVMax = i2;
+  fElectronsAbove10GeVFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetNElectronRange(Int_t n1, Int_t n2)
+{
+  //Sets the electron multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fElectronsMin = n1;
+  fElectronsMax = n2;
+  fElectronsFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetNMuonRange(Int_t n1, Int_t n2)
+{
+  //Sets the muon multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMuonsMin = n1;
+  fMuonsMax = n2;
+  fMuonsFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetNPionRange(Int_t n1, Int_t n2)
+{
+  //Sets the pion multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fPionsMin = n1;
+  fPionsMax = n2;
+  fPionsFlag = kTRUE;
+} 
+
+//----------------------------------------//
+void AliEventTagCuts::SetNKaonRange(Int_t n1, Int_t n2)
+{
+  //Sets the kaon multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fKaonsMin = n1;
+  fKaonsMax = n2;
+  fKaonsFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetNProtonRange(Int_t n1, Int_t n2)
+{
+  //Sets the proton multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fProtonsMin = n1;
+  fProtonsMax = n2;
+  fProtonsFlag = kTRUE;
+} 
+
+//----------------------------------------//
+void AliEventTagCuts::SetNLambdaRange(Int_t n1, Int_t n2)
+{
+  //Sets the lambda multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fLambdasMin = n1;
+  fLambdasMax = n2;
+  fLambdasFlag = kTRUE;
+} 
+//----------------------------------------//
+void AliEventTagCuts::SetNPhotonRange(Int_t n1, Int_t n2)
+{
+  //Sets the photon multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fPhotonsMin = n1;
+  fPhotonsMax = n2;
+  fPhotonFlag = kTRUE;
+} 
+//----------------------------------------//
+void AliEventTagCuts::SetNPi0Range(Int_t n1, Int_t n2)
+{
+  //Sets the pi0 multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fPi0sMin = n1;
+  fPi0sMax = n2; 
+  fPi0sFlag = kTRUE;
+}  
+
+//----------------------------------------//
+void AliEventTagCuts::SetNNeutronRange(Int_t n1, Int_t n2)
+{
+  //Sets the neutron multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fNeutronsMin = n1;
+  fNeutronsMax = n2; 
+  fNeutronsFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetNKaon0Range(Int_t n1, Int_t n2)
+{  
+  //Sets the K0s multiplicity range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fKaon0sMin = n1;
+  fKaon0sMax = n2; 
+  fKaon0sFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetTotalPRange(Float_t r1, Float_t r2)
+{
+  //Sets the total momentum range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fTotalPMin = r1;
+  fTotalPMax = r2;
+  fTotalPFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetMeanPtRange(Float_t r1, Float_t r2)
+{
+  //Sets the mean Pt range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMeanPtMin = r1;
+  fMeanPtMax = r2;
+  fMeanPtFlag = kTRUE;
+}  
+
+//----------------------------------------//
+void AliEventTagCuts::SetMaxPt(Float_t r1)
+{
+  //Sets the lower limit of the max Pt value
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMaxPt = r1; 
+  fMaxPtFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetTotalNeutralPRange(Float_t r1, Float_t r2)
+{  
+  //Sets the total momentum of neutral particles range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fTotalNeutralPMin =r1 ;
+  fTotalNeutralPMax = r2;  
+  fTotalNeutralPFlag = kTRUE;
+}
+//----------------------------------------//
+void AliEventTagCuts::SetMeanNeutralPtPRange(Float_t r1, Float_t r2)
+{  
+  //Sets the mean Pt of neutral particles range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMeanNeutralPtMin = r1;
+  fMeanNeutralPtMax = r2; 
+  fMeanNeutralPtFlag = kTRUE;
+} 
+//----------------------------------------//
+void AliEventTagCuts::SetMaxNeutralPt(Float_t r1)
+{  
+  //Sets the lower limit of the maximum Pt of neutral particles
+  //and the corresponding flag to kTRUE if the cut is used.
+  fMaxNeutralPt = r1; 
+  fMaxNeutralPtFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetEvPlaneAngleRange(Float_t r1, Float_t r2)
+{
+  //Sets the event plane range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fEventPlaneAngleMin = r1;
+  fEventPlaneAngleMax = r2; 
+  fEventPlaneAngleFlag = kTRUE;
+}
+
+//----------------------------------------//
+void AliEventTagCuts::SetHBTRadiiRange(Float_t r1, Float_t r2)
+{
+  //Sets the HBT radii range
+  //and the corresponding flag to kTRUE if the cut is used.
+  fHBTRadiiMin = r1;
+  fHBTRadiiMax = r2; 
+  fHBTRadiiFlag = kTRUE;
+}
+
+//----------------------------------------//
+Bool_t AliEventTagCuts::IsAccepted(AliEventTag *EvTag) const
+{
+  //Returns true if the event is accepted otherwise false.
+  if(fMultFlag)
+    if((EvTag->GetNumOfTracks() < fMultMin) || (EvTag->GetNumOfTracks() > fMultMax))
+      return kFALSE; 
+  
+  if(fVzFlag)
+    if((EvTag->GetVertexZ() < fVzMin) || (EvTag->GetVertexZ() > fVzMax))
+      return kFALSE;
+  
+  if(fVyFlag)
+    if((EvTag->GetVertexY() < fVyMin) || (EvTag->GetVertexY() > fVyMax))
+      return kFALSE;
+  
+  if(fVxFlag)
+    if((EvTag->GetVertexX() < fVxMin) || (EvTag->GetVertexX() > fVxMax))
+      return kFALSE;
+  
+  if(fParticipantsFlag)
+    if((EvTag->GetNumOfParticipants() < fParticipantsMin) || (EvTag->GetNumOfParticipants() > fParticipantMax))
+      return kFALSE; 
+  
+  if(fImpactParamFlag)
+    if((EvTag->GetImpactParameter() < fImpactParamMin) || (EvTag->GetImpactParameter() > fImpactParamMax))
+      return kFALSE; 
+  
+  if(fPVFlag)
+    if((EvTag->GetVertexFlag() != fPrimaryVertexFlag))
+      return kFALSE; 
+  
+  if(fZDCNeutronEnergyFlag)
+    if((EvTag->GetZDCNeutronEnergy() < fZDCNeutronEnergyMin) || (EvTag->GetZDCNeutronEnergy() > fZDCNeutronEnergyMax))
+      return kFALSE; 
+  
+  if(fZDCProtonEnergyFlag)
+    if((EvTag->GetZDCProtonEnergy() < fZDCProtonEnergyMin) || (EvTag->GetZDCProtonEnergy() > fZDCProtonEnergyMax))
+      return kFALSE; 
+  
+  if(fZDCEMEnergyFlag)
+    if((EvTag->GetZDCEMEnergy() < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy() > fZDCEMEnergyMax))
+      return kFALSE; 
+  
+  if(fT0VertexZFlag)
+    if((EvTag->GetT0VertexZ() < fT0VertexZMin) || (EvTag->GetT0VertexZ() > fT0VertexZMax))
+      return kFALSE; 
+  
+  if(fMultPosFlag)
+    if((EvTag->GetNumOfPosTracks() < fMultPosMin) || (EvTag->GetNumOfPosTracks() > fMultPosMax))
+      return kFALSE; 
+  
+  if(fMultNegFlag)
+    if((EvTag->GetNumOfNegTracks() < fMultNegMin) || (EvTag->GetNumOfNegTracks() > fMultNegMax))
+      return kFALSE; 
+  
+  if(fMultNeutrFlag)
+    if((EvTag->GetNumOfNeutrTracks() < fMultNeutrMin) || (EvTag->GetNumOfNeutrTracks() > fMultNeutrMax))
+      return kFALSE; 
+  
+  if(fV0sFlag)
+    if((EvTag->GetNumOfV0s() < fV0sMin) || (EvTag->GetNumOfV0s() > fV0sMax))
+      return kFALSE; 
+  
+  if(fCascadesFlag)
+    if((EvTag->GetNumOfCascades() < fCascadesMin) || (EvTag->GetNumOfCascades() > fCascadesMax))
+      return kFALSE; 
+  
+  if(fkinksFlag)
+    if((EvTag->GetNumOfKinks() < fkinksMin) || (EvTag->GetNumOfKinks() > fkinksMax))
+      return kFALSE; 
+  
+  if(fMaxJetEnergyFlag)
+    if((EvTag->GetMaxJetEnergy() < fMaxJetEnergy))
+      return kFALSE; 
+  
+  if(fNHardPhotonsCandidatesFlag)
+    if((EvTag->GetNumOfHardPhotonsCandidates() < fNHardPhotonsCandidatesMin) || (EvTag->GetNumOfHardPhotonsCandidates() > fNHardPhotonsCandidatesMax))
+      return kFALSE; 
+  
+  if(fMaxNeutralFlag)
+    if((EvTag->GetMaxNeutralEnergy() < fMaxNeutralEnergy))
+      return kFALSE; 
+  
+  if(fChargedAbove1GeVFlag)
+    if((EvTag->GetNumOfChargedAbove1GeV() < fChargedAbove1GeVMin) || (EvTag->GetNumOfChargedAbove1GeV() > fChargedAbove1GeVMax))
+      return kFALSE; 
+  
+  if(fChargedAbove3GeVFlag)
+    if((EvTag->GetNumOfChargedAbove3GeV() < fChargedAbove3GeVMin) || (EvTag->GetNumOfChargedAbove3GeV() > fChargedAbove3GeVMax))
+      return kFALSE; 
+  
+  if(fChargedAbove10GeVFlag)
+    if((EvTag->GetNumOfChargedAbove10GeV() < fChargedAbove10GeVMin) || (EvTag->GetNumOfChargedAbove10GeV() > fChargedAbove10GeVMax))
+      return kFALSE; 
+  
+  if(fMuonsAbove1GeVFlag)
+    if((EvTag->GetNumOfMuonsAbove1GeV() < fMuonsAbove1GeVMin) || (EvTag->GetNumOfMuonsAbove1GeV() > fMuonsAbove1GeVMax))
+      return kFALSE; 
+  
+  if(fMuonsAbove3GeVFlag)
+    if((EvTag->GetNumOfMuonsAbove3GeV() < fMuonsAbove3GeVMin) || (EvTag->GetNumOfMuonsAbove3GeV() > fMuonsAbove3GeVMax))
+      return kFALSE; 
+  
+  if(fMuonsAbove10GeVFlag)
+    if((EvTag->GetNumOfMuonsAbove10GeV() < fMuonsAbove10GeVMin) || (EvTag->GetNumOfMuonsAbove10GeV() > fMuonsAbove10GeVMax))
+      return kFALSE; 
+  
+  if(fElectronsAbove1GeVFlag)
+    if((EvTag->GetNumOfElectronsAbove1GeV()  < fElectronsAbove1GeVMin) || (EvTag->GetNumOfElectronsAbove1GeV()  > fElectronsAbove1GeVMax))
+      return kFALSE; 
+  
+  if(fElectronsAbove3GeVFlag)
+    if((EvTag->GetNumOfElectronsAbove3GeV() < fElectronsAbove3GeVMin) || (EvTag->GetNumOfElectronsAbove3GeV() > fElectronsAbove3GeVMax))
+      return kFALSE; 
+  
+  if(fElectronsAbove10GeVFlag)
+    if((EvTag->GetNumOfElectronsAbove10GeV() < fElectronsAbove10GeVMin) || (EvTag->GetNumOfElectronsAbove10GeV() > fElectronsAbove10GeVMax))
+      return kFALSE; 
+  
+  if(fElectronsFlag)
+    if((EvTag->GetNumOfElectrons() < fElectronsMin) || (EvTag->GetNumOfElectrons() > fElectronsMax))
+      return kFALSE; 
+  
+  if(fMuonsFlag)
+    if((EvTag->GetNumOfMuons() < fMuonsMin) || (EvTag->GetNumOfMuons() > fMuonsMax))
+      return kFALSE; 
+  
+  if(fPionsFlag)
+    if((EvTag->GetNumOfPions() < fPionsMin) || (EvTag->GetNumOfPions() > fPionsMax))
+      return kFALSE; 
+  
+  if(fKaonsFlag)
+    if((EvTag->GetNumOfKaons() < fKaonsMin) || (EvTag->GetNumOfKaons() > fKaonsMax))
+      return kFALSE; 
+  
+  if(fProtonsFlag)
+    if((EvTag->GetNumOfProtons() < fProtonsMin) || (EvTag->GetNumOfProtons() > fProtonsMax))
+      return kFALSE; 
+  
+  if(fLambdasFlag)
+    if((EvTag->GetNumOfLambdas() < fLambdasMin) || (EvTag->GetNumOfLambdas() > fLambdasMax))
+      return kFALSE; 
+  
+  if(fPhotonFlag)
+    if((EvTag->GetNumOfPhotons() < fPhotonsMin) || (EvTag->GetNumOfPhotons() > fPhotonsMax))
+      return kFALSE; 
+  
+  if(fPi0sFlag)
+    if((EvTag->GetNumOfPi0s() < fPi0sMin) || (EvTag->GetNumOfPi0s() > fPi0sMax))
+      return kFALSE; 
+  
+  if(fNeutronsFlag)
+    if((EvTag->GetNumOfNeutrons() < fNeutronsMin) || (EvTag->GetNumOfNeutrons() > fNeutronsMax))
+      return kFALSE; 
+  
+  if(fKaon0sFlag)
+    if((EvTag->GetNumOfKaon0s() < fKaon0sMin) || (EvTag->GetNumOfKaon0s() > fKaon0sMax))
+      return kFALSE; 
+  
+  if(fTotalPFlag)
+    if((EvTag->GetTotalMomentum() < fTotalPMin) || (EvTag->GetTotalMomentum() > fTotalPMax))
+      return kFALSE; 
+  
+  if(fMeanPtFlag)
+    if((EvTag->GetMeanPt() < fMeanPtMin) || (EvTag->GetMeanPt() > fMeanPtMax))
+      return kFALSE; 
+  
+  if(fMaxPtFlag)
+    if((EvTag->GetMaxPt() < fMaxPt))
+      return kFALSE; 
+  
+  if(fTotalNeutralPFlag)
+    if((EvTag->GetNeutralTotalMomentum() < fTotalNeutralPMin) || (EvTag->GetNeutralTotalMomentum() > fTotalNeutralPMax))
+      return kFALSE; 
+  
+  if(fMeanNeutralPtFlag)
+    if((EvTag->GetNeutralMeanPt() < fMeanNeutralPtMin) || (EvTag->GetNeutralMeanPt() >fMeanNeutralPtMax ))
+      return kFALSE; 
+  
+  if(fMaxNeutralPtFlag)
+    if((EvTag->GetNeutralMaxPt() < fMaxNeutralPt))
+      return kFALSE; 
+  
+  if(fEventPlaneAngleFlag)
+    if((EvTag->GetEventPlaneAngle() < fEventPlaneAngleMin) || (EvTag->GetEventPlaneAngle() > fEventPlaneAngleMax))
+      return kFALSE; 
+  
+  if(fHBTRadiiFlag)
+    if((EvTag->GetHBTRadii() < fHBTRadiiMin) || (EvTag->GetHBTRadii() > fHBTRadiiMax))
+      return kFALSE; 
+  
+  return kTRUE;
+}
diff --git a/STEER/AliEventTagCuts.h b/STEER/AliEventTagCuts.h
new file mode 100644 (file)
index 0000000..a1dc30a
--- /dev/null
@@ -0,0 +1,192 @@
+#ifndef ALIEVENTTAGCUTS_H
+#define ALIEVENTTAGCUTS_H
+/*  See cxx source for full Copyright notice */
+
+
+/* $Id$ */
+
+//-------------------------------------------------------------------------
+//                       Class AliEventTagCuts
+//   This is the class for the cuts in event tags
+//
+//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
+//-------------------------------------------------------------------------
+
+#include <TObject.h>
+
+class AliEventTag;
+
+class AliEventTagCuts : public TObject
+{
+ public:
+  AliEventTagCuts();
+  
+  ~AliEventTagCuts();
+
+  void Reset();
+  
+  void SetParticipantsRange(Int_t i1, Int_t i2);
+  void SetImpactParamRange(Float_t r1, Float_t r2);
+
+  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 SetPrimaryVertexFlag(Int_t i);
+
+  void SetZDCNeutrRange(Float_t r1, Float_t r2);
+  void SetZDCProtRange(Float_t r1, Float_t r2);
+  void SetZDCEMRange(Float_t r1, Float_t r2);
+  void SetT0VertexZRange(Float_t r1, Float_t r2);
+
+  void SetMultiplicityRange(Int_t n1, Int_t n2);
+  void SetPosMultiplicityRange(Int_t n1, Int_t n2);
+  void SetNegMultiplicityRange(Int_t n1, Int_t n2);
+  void SetNeutrMultiplicityRange(Int_t n1, Int_t n2);
+  void SetV0sRange(Int_t n1, Int_t n2);
+  void SetCascadesRange(Int_t n1, Int_t n2);
+  void SetKinksRange(Int_t n1, Int_t n2);
+  void SetMaxJetEnergy(Float_t r1);
+  void SetMaxNeutralEnergy(Float_t r1);
+  void SetHardPhotonsRange(Int_t i1, Int_t i2);
+  void SetNChargedAbove1GeVRange(Int_t i1, Int_t i2);
+  void SetNChargedAbove3GeVRange(Int_t i1, Int_t i2);
+  void SetNChargedAbove10GeVRange(Int_t i1, Int_t i2);
+  void SetNMuonsAbove1GeVRange(Int_t i1, Int_t i2);
+  void SetNMuonsAbove3GeVRange(Int_t i1, Int_t i2);
+  void SetNMuonsAbove10GeVRange(Int_t i1, Int_t i2);
+  void SetNElectronsAbove1GeVRange(Int_t i1, Int_t i2);
+  void SetNElectronsAbove3GeVRange(Int_t i1, Int_t i2);
+  void SetNElectronsAbove10GeVRange(Int_t i1, Int_t i2);
+  void SetNElectronRange(Int_t n1, Int_t n2);
+  void SetNMuonRange(Int_t n1, Int_t n2);
+  void SetNPionRange(Int_t n1, Int_t n2);
+  void SetNKaonRange(Int_t n1, Int_t n2);
+  void SetNProtonRange(Int_t n1, Int_t n2);
+  void SetNLambdaRange(Int_t n1, Int_t n2);
+  void SetNPhotonRange(Int_t n1, Int_t n2);
+  void SetNPi0Range(Int_t n1, Int_t n2);
+  void SetNNeutronRange(Int_t n1, Int_t n2);
+  void SetNKaon0Range(Int_t n1, Int_t n2);
+  void SetTotalPRange(Float_t r1, Float_t r2);
+  void SetMeanPtRange(Float_t r1, Float_t r2);
+  void SetMaxPt(Float_t r1);
+  void SetTotalNeutralPRange(Float_t r1, Float_t r2);
+  void SetMeanNeutralPtPRange(Float_t r1, Float_t r2);
+  void SetMaxNeutralPt(Float_t r1);
+  void SetEvPlaneAngleRange(Float_t r1, Float_t r2);
+  void SetHBTRadiiRange(Float_t r1, Float_t r2);
+  Bool_t IsAccepted(AliEventTag *EvTag) const;
+
+ private:
+  Float_t fVxMin, fVxMax;  //Definition of the range of the Vx
+  Bool_t fVxFlag;          //Shows whether this cut is used or not
+  Float_t fVyMin, fVyMax;  //Definition of the range of the Vy
+  Bool_t fVyFlag;          //Shows whether this cut is used or not
+  Float_t fVzMin, fVzMax;  //Definition of the range of the Vz
+  Bool_t fVzFlag;          //Shows whether this cut is used or not
+  Int_t fParticipantsMin, fParticipantMax; //# participants range
+  Bool_t fParticipantsFlag;//Shows whether this cut is used or not
+  Float_t fImpactParamMin, fImpactParamMax; //Impact parameter range
+  Bool_t fImpactParamFlag; //Shows whether this cut is used or not
+  Int_t fPrimaryVertexFlag; //Primary vertex flag: 0->not found, 1->found
+  Bool_t fPVFlag;          //Shows whether this cut is used or not
+  
+  Float_t fZDCNeutronEnergyMin, fZDCNeutronEnergyMax; //ZDC min,max - neutron
+  Bool_t fZDCNeutronEnergyFlag;//Shows whether this cut is used or not
+  Float_t fZDCProtonEnergyMin, fZDCProtonEnergyMax; //ZDC min,max - proton
+  Bool_t fZDCProtonEnergyFlag;//Shows whether this cut is used or not
+  Float_t fZDCEMEnergyMin, fZDCEMEnergyMax; //ZDC min,max - em
+  Bool_t fZDCEMEnergyFlag;//Shows whether this cut is used or not
+  Float_t fT0VertexZMin, fT0VertexZMax; //T0 min, max
+  Bool_t fT0VertexZFlag;//Shows whether this cut is used or not
+  
+  Int_t fMultMin, fMultMax;  //Definition of the range of the multiplicity
+  Bool_t fMultFlag;//Shows whether this cut is used or not
+  Int_t fMultPosMin, fMultPosMax; //Positive tracks multiplicity range
+  Bool_t fMultPosFlag;//Shows whether this cut is used or not
+  Int_t fMultNegMin, fMultNegMax; //Negative tracks multiplicity range
+  Bool_t fMultNegFlag;//Shows whether this cut is used or not
+  Int_t fMultNeutrMin, fMultNeutrMax; //Neutral tracks multiplicity range
+  Bool_t fMultNeutrFlag;//Shows whether this cut is used or not
+  Int_t fV0sMin, fV0sMax; //Range of V0s
+  Bool_t fV0sFlag;//Shows whether this cut is used or not
+  Int_t fCascadesMin, fCascadesMax; //Range of cascades
+  Bool_t fCascadesFlag;//Shows whether this cut is used or not
+  Int_t fkinksMin, fkinksMax; //Range of kinks
+  Bool_t fkinksFlag;//Shows whether this cut is used or not
+  
+  Float_t fMaxJetEnergy; //max jet energy info
+  Bool_t fMaxJetEnergyFlag;//Shows whether this cut is used or not
+  
+  Int_t fNHardPhotonsCandidatesMin, fNHardPhotonsCandidatesMax; //Hard photons candidates
+  Bool_t fNHardPhotonsCandidatesFlag;//Shows whether this cut is used or not
+  Float_t fMaxNeutralEnergy; //max neutral energy info
+  Bool_t fMaxNeutralFlag;//Shows whether this cut is used or not
+  
+  Int_t fChargedAbove1GeVMin, fChargedAbove1GeVMax;//Definition of the range of the number of charged above 1GeV
+  Bool_t fChargedAbove1GeVFlag;//Shows whether this cut is used or not
+  Int_t fChargedAbove3GeVMin, fChargedAbove3GeVMax;//Definition of the range of the number of charged above 3GeV
+  Bool_t fChargedAbove3GeVFlag;//Shows whether this cut is used or not
+  Int_t fChargedAbove10GeVMin, fChargedAbove10GeVMax;//Definition of the range of the number of charged above 10GeV
+  Bool_t fChargedAbove10GeVFlag;//Shows whether this cut is used or not
+  Int_t fMuonsAbove1GeVMin, fMuonsAbove1GeVMax;//Definition of the range of the number of muons above 1GeV
+  Bool_t fMuonsAbove1GeVFlag;//Shows whether this cut is used or not
+  Int_t fMuonsAbove3GeVMin, fMuonsAbove3GeVMax;//Definition of the range of the number of muons above 3GeV
+  Bool_t fMuonsAbove3GeVFlag;//Shows whether this cut is used or not
+  Int_t fMuonsAbove10GeVMin, fMuonsAbove10GeVMax; //Definition of the range of the number of muons above 10GeV
+  Bool_t fMuonsAbove10GeVFlag;//Shows whether this cut is used or not
+  Int_t fElectronsAbove1GeVMin, fElectronsAbove1GeVMax;//Definition of the range of the number of electorns above 1GeV
+  Bool_t fElectronsAbove1GeVFlag;//Shows whether this cut is used or not
+  Int_t fElectronsAbove3GeVMin, fElectronsAbove3GeVMax;//Definition of the range of the number of electorns above 3GeV
+  Bool_t fElectronsAbove3GeVFlag;//Shows whether this cut is used or not
+  Int_t fElectronsAbove10GeVMin,fElectronsAbove10GeVMax;//Definition of the range of the number of electorns above 10GeV
+  Bool_t fElectronsAbove10GeVFlag;//Shows whether this cut is used or not
+  
+  Int_t fElectronsMin, fElectronsMax; //Number of electrons range
+  Bool_t fElectronsFlag;//Shows whether this cut is used or not
+  Int_t fMuonsMin, fMuonsMax;  //Number of muons range
+  Bool_t fMuonsFlag;//Shows whether this cut is used or not
+  Int_t fPionsMin, fPionsMax; //Number of pions range
+  Bool_t fPionsFlag;//Shows whether this cut is used or not
+  Int_t fKaonsMin, fKaonsMax; //Number of kaons range
+  Bool_t fKaonsFlag;//Shows whether this cut is used or not
+  Int_t fProtonsMin, fProtonsMax; //Number of protons range
+  Bool_t fProtonsFlag;//Shows whether this cut is used or not
+  Int_t fLambdasMin, fLambdasMax; //Number of lambdas range
+  Bool_t fLambdasFlag;//Shows whether this cut is used or not
+  Int_t fPhotonsMin, fPhotonsMax; //Number of photons range
+  Bool_t fPhotonFlag;//Shows whether this cut is used or not
+  Int_t fPi0sMin, fPi0sMax; //Number of Pi0s range
+  Bool_t fPi0sFlag;//Shows whether this cut is used or not
+  Int_t fNeutronsMin, fNeutronsMax; //Number of neutrons range
+  Bool_t fNeutronsFlag;//Shows whether this cut is used or not
+  Int_t fKaon0sMin, fKaon0sMax; //Number of K0s range
+  Bool_t fKaon0sFlag;//Shows whether this cut is used or not
+  
+  Float_t fTotalPMin, fTotalPMax; //Range of the sum of the momentum per event
+  Bool_t fTotalPFlag;//Shows whether this cut is used or not
+  Float_t fMeanPtMin, fMeanPtMax; //Range of mean Pt per event
+  Bool_t fMeanPtFlag;//Shows whether this cut is used or not
+  Float_t fMaxPt; //Max Pt for each event
+  Bool_t fMaxPtFlag;//Shows whether this cut is used or not
+  Float_t fTotalNeutralPMin, fTotalNeutralPMax; //Sum of the momentum per event for neutral
+  Bool_t fTotalNeutralPFlag;//Shows whether this cut is used or not
+  Float_t fMeanNeutralPtMin, fMeanNeutralPtMax; //Mean Pt per event for neutral
+  Bool_t fMeanNeutralPtFlag;//Shows whether this cut is used or not
+  Float_t fMaxNeutralPt; //Max Pt for each event for neutral
+  Bool_t fMaxNeutralPtFlag;//Shows whether this cut is used or not
+  Float_t fEventPlaneAngleMin, fEventPlaneAngleMax; //event plane info
+  Bool_t fEventPlaneAngleFlag;//Shows whether this cut is used or not
+  Float_t fHBTRadiiMin, fHBTRadiiMax; //HBT info
+  Bool_t fHBTRadiiFlag;//Shows whether this cut is used or not
+
+  ClassDef(AliEventTagCuts, 1)
+} ;
+
+#endif
diff --git a/STEER/AliTagAnalysis.cxx b/STEER/AliTagAnalysis.cxx
new file mode 100644 (file)
index 0000000..1a12837
--- /dev/null
@@ -0,0 +1,177 @@
+/**************************************************************************
+ * 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$ */
+
+//-----------------------------------------------------------------
+//           AliTagAnalysis class
+//   This is the class to deal with the tag analysis
+//   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
+//-----------------------------------------------------------------
+
+//ROOT
+#include <TSystem.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <TEventList.h>
+
+//ROOT-AliEn
+#include <TGridResult.h>
+
+#include "AliLog.h"
+
+#include "AliRunTag.h"
+#include "AliEventTag.h"
+#include "AliTagAnalysis.h"
+#include "AliEventTagCuts.h"
+
+class TTree;
+
+ClassImp(AliTagAnalysis)
+
+TChain *AliTagAnalysis::fgChain = 0;
+
+//______________________________________________________________________________
+AliTagAnalysis::AliTagAnalysis(): TObject()//local mode
+{
+  //==============Default constructor for a AliTagAnalysis==================
+  ftagresult = 0;
+}
+
+//______________________________________________________________________________
+AliTagAnalysis::~AliTagAnalysis()
+{
+//================Default destructor for a AliTagAnalysis=======================
+}
+
+//______________________________________________________________________________
+void AliTagAnalysis::ChainLocalTags(const char *dirname) //local version
+{
+  //Searches the entries of the provided direcory
+  //Chains the tags that are stored locally
+  fTagDirName = dirname;
+  TString fTagFilename;
+  
+  TChain *fgChain = new TChain("T");
+  fChain = fgChain;
+  
+  const char * tagPattern = "tag";
+  // Open the working directory
+  void * dirp = gSystem->OpenDirectory(fTagDirName);
+  const char * name = 0x0;
+  // Add all files matching *pattern* to the chain
+  while((name = gSystem->GetDirEntry(dirp)))
+    {
+      if (strstr(name,tagPattern))
+       { 
+         fTagFilename = fTagDirName;
+         fTagFilename += "/";
+         fTagFilename += name;
+               
+         TFile * fTag = TFile::Open(fTagFilename);
+         if((!fTag) || (!fTag->IsOpen()))
+           {
+             AliError(Form("Tag file not opened!!!"));
+             continue;
+           } 
+         fChain->Add(fTagFilename);  
+         fTag->Close();
+         delete fTag;
+       }//pattern check
+    }//directory loop
+  AliInfo(Form("Chained tag files: %d ",fChain->GetEntries()));
+}
+
+
+//______________________________________________________________________________
+void AliTagAnalysis::ChainGridTags(TGridResult *res)
+{
+  //Loops overs the entries of the TGridResult
+  //Chains the tags that are stored in the GRID
+  ftagresult = res;
+  Int_t nEntries = ftagresult->GetEntries();
+  TChain *fgChain = new TChain("T");
+  fChain = fgChain;
+
+  TString gridname = "alien://";
+  TString alienUrl;
+  for(Int_t i = 0; i < nEntries; i++)
+    {
+      alienUrl = ftagresult->GetKey(i,"turl");
+      TFile *f = TFile::Open(alienUrl,"READ");
+      fChain->Add(alienUrl);
+      //f->Close();
+      delete f;         
+    }//grid result loop  
+}
+
+
+//______________________________________________________________________________
+TList *AliTagAnalysis::QueryTags(AliEventTagCuts *EvTagCuts)
+{
+  //Queries the tag chain using the defined 
+  //event tag cuts from the AliEventTagCuts object
+  AliInfo(Form("Querying the tags........"));
+  
+  //file info list
+  TList *list = new TList();
+  
+  Int_t iAccepted = 0, evCounter = 0;
+  
+  //Defining tag objects
+  AliRunTag *tag = new AliRunTag;
+  AliEventTag *evTag = new AliEventTag;
+  fChain->SetBranchAddress("AliTAG",&tag);
+
+  Long64_t size = -1;
+  const char* md5 = 0;
+  const char* guid = 0;
+  const char* turl = 0;
+
+  for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++)
+    {
+      TEventList *fEventList = new TEventList();
+      evCounter = 0;
+      fChain->GetEntry(iTagFiles);
+      Int_t iEvents = tag->GetNEvents();
+      const TClonesArray *tagList = tag->GetEventTags();
+      for(Int_t i = 0; i < iEvents; i++)
+       {
+         evTag = (AliEventTag *) tagList->At(i);
+         size = evTag->GetSize();
+         md5 = evTag->GetMD5();
+         guid = evTag->GetGUID(); 
+         turl = evTag->GetTURL(); 
+         if(EvTagCuts->IsAccepted(evTag))
+           {
+             fEventList->Enter(i);
+             evCounter++;
+           
+             iAccepted++;
+           }
+       }//event loop
+
+      //adding a TFileInfo object to the list
+      if(evCounter != 0)
+       list->Add(new TFileInfo(turl,size,guid,md5,-1,-1,-1,fEventList));
+      fEventList->Clear("");
+      delete fEventList;
+    }//tag file loop
+  AliInfo(Form("Accepted events: %d",iAccepted));
+   
+  return list;
+}
+
+
diff --git a/STEER/AliTagAnalysis.h b/STEER/AliTagAnalysis.h
new file mode 100644 (file)
index 0000000..f8e0f88
--- /dev/null
@@ -0,0 +1,54 @@
+#ifndef ALITAGANALYSIS_H
+#define ALITAGANALYSIS_H
+/*  See cxx source for full Copyright notice */
+
+
+/* $Id$ */
+
+//-------------------------------------------------------------------------
+//                          Class AliTagAnalysis
+//   This is the AliTagAnalysis class for the tag analysis
+//
+//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
+//-------------------------------------------------------------------------
+
+
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+//                        AliTagAnalysis                                //
+//                                                                      //
+//           Implementation of the tag analysis mechanism.              //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+
+//ROOT
+#include <TObject.h>
+
+class AliEventTag;
+class TChain;
+class AliEventTagCuts;
+class TGridResult;
+
+class AliTagAnalysis : public TObject {
+ public:
+  AliTagAnalysis();
+  ~AliTagAnalysis(); 
+
+  void ChainLocalTags(const char *dirname);
+  void ChainGridTags(TGridResult *result);
+  TList *QueryTags(AliEventTagCuts *EvTagCuts);
+   
+ protected:
+  TGridResult *ftagresult; //the results from the tag grid query     
+  TString fTagDirName; //the location of the locally stored tags
+    
+  static TChain *fgChain; //tag chain 
+  TChain *fChain; //tag chain 
+       
+  ClassDef(AliTagAnalysis,0)  
+};
+
+#endif
+
index b592f78eecdad34e7d7cc1c6a088a89f8fcd237f..1b683e6599ba1099000ae4049bc077fd86ed6763 100644 (file)
 #pragma link C++ class AliEventTag+;
 
 #pragma link C++ class AliTagCreator+;
-//#pragma link C++ class AliGuidEventList+;
-//#pragma link C++ class AliTagAnalysis+;
-//#pragma link C++ class AliEventTagCuts+;
+#pragma link C++ class AliTagAnalysis+;
+#pragma link C++ class AliEventTagCuts+;
 
 #pragma link C++ class AliAlignObj+;
 #pragma link C++ class AliAlignObjAngles+;
index 86de5531f5a9a722f4cc2c624c16bb325414c463..b8e45cc7c24cdc93de069545fc9d2989e3693363 100644 (file)
@@ -20,6 +20,7 @@ AliMemoryWatcher.cxx \
 AliVertexer.cxx \
 AliMC.cxx AliSimulation.cxx AliReconstruction.cxx AliVertexGenFile.cxx \
 AliRunTag.cxx AliLHCTag.cxx AliDetectorTag.cxx AliEventTag.cxx AliTagCreator.cxx\
+AliTagAnalysis.cxx AliEventTagCuts.cxx \
 AliCDBEntry.cxx AliCDBId.cxx AliCDBMetaData.cxx \
 AliCDBPath.cxx AliCDBRunRange.cxx AliCDBManager.cxx\
 AliCDBStorage.cxx AliCDBLocal.cxx AliCDBDump.cxx AliCDBGrid.cxx\