Fixing coding violations (Livio, Pietro)
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 5 Mar 2008 07:04:08 +0000 (07:04 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 5 Mar 2008 07:04:08 +0000 (07:04 +0000)
PWG3/AliAODDimuon.cxx
PWG3/AliAODDimuon.h
PWG3/AliAODEventInfo.cxx
PWG3/AliAODEventInfo.h
PWG3/AliAnalysisTaskMuonAODfromGeneral.cxx
PWG3/AliAnalysisTaskMuonAODfromGeneral.h

index 93ef32d..3b06c55 100644 (file)
-/* AliAODDimuon: a class for AODs for the MUON Arm of the ALICE Experiment
- * Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
- * INFN of Torino - Italy
- */
+// AliAODDimuon: a class for AODs for the MUON Arm of the ALICE Experiment
+// Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
+// INFN of Torino - Italy
+//
+// The class defines a dimuon pair object from two AliAODTrack objects.
+// AliAODDimuon objects are supposed to be added to the AliAODEvent structure
+// during analysis. They would then allow to calculate the dimuon-related
+// kinematic variables with a minimal disk occupancy.
+// The payload of the class has been reduced to two pointers to the two
+// tracks with the addition of a pointer to the AliAODEventInfo. An instance of
+// this class has also to be added to the AliAODEvent structure to provide
+// additional information that is specific to MUON and therefore has not been
+// included into the AOD header.
+// Two transient data members are not stored on file as they can be recomputed
+// at runtime.
+//
 
 #include "AliAODDimuon.h"
+#include "TLorentzVector.h"
 #define AliAODDimuon_CXX
 
 ClassImp(AliAODDimuon)
 
-AliAODDimuon::AliAODDimuon():ei(0),p(0),MProton(0.93827231)
+//______________________________________________________________________________
+AliAODDimuon::AliAODDimuon():fEi(0),fP(0),fMProton(0.93827231)
 {
   // default constructor
-  //mu[0]=0;
-  //mu[1]=0;
+  fMu[0]=0;
+  fMu[1]=0;
 }
 
-AliAODDimuon::AliAODDimuon(const AliAODDimuon& dimu):p(0),MProton(0.93827231)
+//______________________________________________________________________________
+AliAODDimuon::AliAODDimuon(const AliAODDimuon& dimu):fP(0),fMProton(0.93827231)
 {
-  // default constructor
-  mu[0]=dimu.mu[0];
-  mu[1]=dimu.mu[1];
-  ei=dimu.ei;
+  // copy constructor
+  fMu[0]=dimu.Mu(0);
+  fMu[1]=dimu.Mu(1);
+  fEi=dimu.Ei();
+}
+
+//______________________________________________________________________________
+AliAODDimuon &AliAODDimuon::operator=(const AliAODDimuon& dimu)
+{
+  // assignment operator
+  fP=0;
+  fMProton=0.93827231;
+  if(&dimu != this){
+    fMu[0]=dimu.Mu(0);
+    fMu[1]=dimu.Mu(1);
+    fEi=dimu.Ei();
+  }
+  return *this;
 }
 
-AliAODDimuon::AliAODDimuon(TObject *mu0, TObject *mu1, TObject *eipoint):p(0),MProton(0.93827231)
+//______________________________________________________________________________
+AliAODDimuon::AliAODDimuon(TObject *mu0, TObject *mu1, TObject *ei):
+  fP(0),fMProton(0.93827231)
 {
-  ///printf("Creating dimuon from %p %p\n",mu0,mu1);
-  mu[0]=mu0;
-  mu[1]=mu1;
-  ei=eipoint;
+  // Creates a dimuon pair from two tracks and the EventInfo
+  
+  //printf("Creating dimuon from %p %p\n",mu0,mu1);
+  fMu[0]=mu0;
+  fMu[1]=mu1;
+  fEi=ei;
 }
 
 //______________________________________________________________________________
 AliAODDimuon::~AliAODDimuon()
 {
   // destructor
-  if(p)delete p;
-  p=0;
+  if(fP)delete fP;
+  fP=0;
 }
 
+//______________________________________________________________________________
 void AliAODDimuon::BookP(){
-  static UInt_t UnID[2]={0,0};
-  if(!p){
-    p=new TLorentzVector(Px(),Py(),Pz(),E());
-    UnID[0]=mu[0].GetUniqueID();
-    UnID[1]=mu[1].GetUniqueID();
+  // Fills the dimuon momentum if not filled yet
+  static UInt_t unID[2]={0,0};
+  if(!fP){
+    fP=new TLorentzVector(Px(),Py(),Pz(),E());
+    unID[0]=fMu[0].GetUniqueID();
+    unID[1]=fMu[1].GetUniqueID();
   }
   // For efficiency reasons
-  if((UnID[0]!=mu[0].GetUniqueID())||(UnID[1]!=mu[1].GetUniqueID())){
-    p->SetPxPyPzE(Px(),Py(),Pz(),E());
-    UnID[0]=mu[0].GetUniqueID();
-    UnID[1]=mu[1].GetUniqueID();
+  if((unID[0]!=fMu[0].GetUniqueID())||(unID[1]!=fMu[1].GetUniqueID())){
+    fP->SetPxPyPzE(Px(),Py(),Pz(),E());
+    unID[0]=fMu[0].GetUniqueID();
+    unID[1]=fMu[1].GetUniqueID();
   }
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Px() const {
+  // Px of the dimuon
   if(this->CheckPointers())return -999999999;
-  return ((AliAODTrack*)mu[0].GetObject())->Px()+((AliAODTrack*)mu[1].GetObject())->Px();
+  return ((AliAODTrack*)fMu[0].GetObject())->Px()+
+         ((AliAODTrack*)fMu[1].GetObject())->Px();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Py() const {
+  // Py of the dimuon
   if(this->CheckPointers())return -999999999;
-  return ((AliAODTrack*)mu[0].GetObject())->Py()+((AliAODTrack*)mu[1].GetObject())->Py();
+  return ((AliAODTrack*)fMu[0].GetObject())->Py()+
+         ((AliAODTrack*)fMu[1].GetObject())->Py();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Pz() const {
+  // Pz of the dimuon
   if(this->CheckPointers())return -999999999;
-  return ((AliAODTrack*)mu[0].GetObject())->Pz()+((AliAODTrack*)mu[1].GetObject())->Pz();
+  return ((AliAODTrack*)fMu[0].GetObject())->Pz()+
+         ((AliAODTrack*)fMu[1].GetObject())->Pz();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Pt() const {
+  // Pt of the dimuon
   if(this->CheckPointers())return -999999999;
   Double_t px=Px();
   Double_t py=Py();
@@ -83,193 +125,234 @@ Double_t AliAODDimuon::Pt() const {
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::E() const {
+  // Dimuon energy
   if(this->CheckPointers())return -999999999;
-  return ((AliAODTrack*)mu[0].GetObject())->E()+((AliAODTrack*)mu[1].GetObject())->E();
+  return ((AliAODTrack*)fMu[0].GetObject())->E()+
+         ((AliAODTrack*)fMu[1].GetObject())->E();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::P() const {
+  // This is just to override the virtual function
   printf("You should never call: Double_t AliAODDimuon::P() const\n");
   return -999999999;
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::P() {
+  // Dimuon momentum
   if(this->CheckPointers())return -999999999;
   BookP();
-  return p->P();
+  return fP->P();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::M() const {
+  // This is just to override the virtual function
   printf("You should never call: Double_t AliAODDimuon::M() const\n");
   return -999999999;
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::M() {
+  // Dimuon invariant mass
+  if(this->CheckPointers())return -999999999;
+  BookP();
+  return fP->M();
+}
+
+//______________________________________________________________________________
+Double_t AliAODDimuon::Mass() {
+  // Dimuon invariant mass
   if(this->CheckPointers())return -999999999;
   BookP();
-  return p->M();
+  return fP->M();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Eta() const {
+  // This is just to override the virtual function
   printf("You should never call: Double_t AliAODDimuon::Eta() const\n");
   return -999999999;
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Eta() {
+  // Dimuon pseudorapidity
   if(this->CheckPointers())return -999999999;
   BookP();
-  return p->Eta();
+  return fP->Eta();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Phi() const {
+  // This is just to override the virtual function
   printf("You should never call: Double_t AliAODDimuon::Phi() const\n");
   return -999999999;
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Phi() {
+  // Dimuon asimuthal angle
   if(this->CheckPointers())return -999999999;
   BookP();
-  return p->Phi();
+  return fP->Phi();
 }
 //______________________________________________________________________________
 Double_t AliAODDimuon::Theta() const {
+  // This is just to override the virtual function
   printf("You should never call: Double_t AliAODDimuon::Theta() const\n");
   return -999999999;
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Theta() {
+  // Dimuon polar angle
   if(this->CheckPointers())return -999999999;
   BookP();
-  return p->Theta();
+  return fP->Theta();
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Y() const {
+  // This is just to override the virtual function
   printf("You should never call: Double_t AliAODDimuon::Y() const\n");
   return -999999999;
 }
 
 //______________________________________________________________________________
 Double_t AliAODDimuon::Y() {
+  // Dimuon rapidity
   if(this->CheckPointers())return -999999999;
   BookP();
-  return p->Rapidity();
+  return fP->Rapidity();
 }
 
 //______________________________________________________________________________
-Short_t AliAODDimuon::Charge() const
-{
+Short_t AliAODDimuon::Charge() const {
+  // Dimuon charge
   if(this->CheckPointers())return -999;
-  return ((AliAODTrack*)mu[0].GetObject())->Charge()+((AliAODTrack*)mu[1].GetObject())->Charge();
+  return ((AliAODTrack*)fMu[0].GetObject())->Charge()+
+         ((AliAODTrack*)fMu[1].GetObject())->Charge();
 }
 
 //______________________________________________________________________________
 Int_t AliAODDimuon::CheckPointers() const{
-  if(mu[0]==0||mu[1]==0){
+  // Checks if the track pointers have been initialized
+  if(fMu[0]==0||fMu[1]==0){
     printf("Dimuon not initialized\n");
     return -999;
   }
-  if((mu[0].GetObject())==0||(mu[1].GetObject())==0){
-    printf("Can not get objects. Got: %p %p\n",mu[0].GetObject(),mu[1].GetObject());
+  if((fMu[0].GetObject())==0||(fMu[1].GetObject())==0){
+    printf("Can not get objects. Got: %p %p\n",fMu[0].GetObject(),fMu[1].GetObject());
     return -999;
   }
   return 0;
 }
 
 //______________________________________________________________________________
-Double_t AliAODDimuon::xf() {
-  Double_t EBeam=((AliAODEventInfo*)ei.GetObject())->EBeam();
-  if(EBeam<=0){
-    printf("AliAODDimuon::xf: can not compute xf with EBeam=%f\n",EBeam);
+void AliAODDimuon::SetMu(Int_t imu, AliAODTrack *mu){
+  // Assign a track pointer
+  if (imu==0||imu==1){
+    fMu[imu]=mu;
+  }
+}
+
+//______________________________________________________________________________
+void AliAODDimuon::SetMuons(AliAODTrack *mu0, AliAODTrack *mu1){
+  // Assign the track pointers
+  fMu[0]=mu0;
+  fMu[1]=mu1;
+}
+
+//______________________________________________________________________________
+Double_t AliAODDimuon::XF() {
+  // Dimuon Feynman x
+  Double_t ebeam=((AliAODEventInfo*)fEi.GetObject())->EBeam();
+  if(ebeam<=0){
+    printf("AliAODDimuon::xf: can not compute xf with EBeam=%f\n",ebeam);
     return -999999999;
   }
   if(this->CheckPointers())return -999999999;
   BookP();
-  Double_t MDimu=M();
-  Double_t PMax=TMath::Sqrt(EBeam*EBeam-MDimu*MDimu);
-  return Pz()/PMax;
+  Double_t mDimu=M();
+  Double_t pMax=TMath::Sqrt(ebeam*ebeam-mDimu*mDimu);
+  return Pz()/pMax;
 }
 
 //______________________________________________________________________________
 // Calculation the Collins-Soper angle (adapted from code by R. Arnaldi)
 Double_t AliAODDimuon::CostCS(){
+  // Cosinus of the Collins-Soper polar decay angle
   if(CheckPointers())return -999999999;
-  if(ei==0){
+  if(fEi==0){
     printf("Pointer to MuonHeader not initialized\n");
     return -999999999;
   }
-  if(ei.GetObject()==0){
+  if(fEi.GetObject()==0){
     printf("Can not get MuonHeader object\n");
     return -999999999;
   }
-  Double_t EBeam=((AliAODEventInfo*)ei.GetObject())->EBeam();
-  if(EBeam<=0){
-    printf("Can not compute costCS with EBeam=%f\n",EBeam);
+  Double_t ebeam=((AliAODEventInfo*)fEi.GetObject())->EBeam();
+  if(ebeam<=0){
+    printf("Can not compute costCS with EBeam=%f\n",ebeam);
     return -999999999;
   }
-  Double_t mp=MProton;
-  Double_t PBeam=TMath::Sqrt(EBeam*EBeam-mp*mp);
-  Double_t pla10=((AliAODTrack*)mu[0].GetObject())->Px();
-  Double_t pla11=((AliAODTrack*)mu[0].GetObject())->Py();
-  Double_t pla12=((AliAODTrack*)mu[0].GetObject())->Pz();
-  Double_t e1=((AliAODTrack*)mu[0].GetObject())->E();
-  Double_t Mu1Charge=((AliAODTrack*)mu[0].GetObject())->Charge();
-  Double_t pla20=((AliAODTrack*)mu[1].GetObject())->Px();
-  Double_t pla21=((AliAODTrack*)mu[1].GetObject())->Py();
-  Double_t pla22=((AliAODTrack*)mu[1].GetObject())->Pz();
-  Double_t e2=((AliAODTrack*)mu[1].GetObject())->E();
-  Double_t Mu2Charge=((AliAODTrack*)mu[1].GetObject())->Charge();
+  Double_t mp=fMProton;
+  Double_t pbeam=TMath::Sqrt(ebeam*ebeam-mp*mp);
+  Double_t pla10=((AliAODTrack*)fMu[0].GetObject())->Px();
+  Double_t pla11=((AliAODTrack*)fMu[0].GetObject())->Py();
+  Double_t pla12=((AliAODTrack*)fMu[0].GetObject())->Pz();
+  Double_t e1=((AliAODTrack*)fMu[0].GetObject())->E();
+  Double_t mu1Charge=((AliAODTrack*)fMu[0].GetObject())->Charge();
+  Double_t pla20=((AliAODTrack*)fMu[1].GetObject())->Px();
+  Double_t pla21=((AliAODTrack*)fMu[1].GetObject())->Py();
+  Double_t pla22=((AliAODTrack*)fMu[1].GetObject())->Pz();
+  Double_t e2=((AliAODTrack*)fMu[1].GetObject())->E();
+  Double_t mu2Charge=((AliAODTrack*)fMu[1].GetObject())->Charge();
 
   // Fill the Lorentz vector for projectile and target
-  // For the moment we consider no crossing angle
+  // For the moment we do not consider the crossing angle
   // Projectile runs towards the MUON arm
-  TLorentzVector PProjLab(0.,0.,-PBeam,EBeam); // projectile
-  TLorentzVector PTargLab(0.,0., PBeam,EBeam); // target
+  TLorentzVector pProjLab(0.,0.,-pbeam,ebeam); // projectile
+  TLorentzVector pTargLab(0.,0., pbeam,ebeam); // target
   //
   // --- Get the muons parameters in the LAB frame
   //
-  TLorentzVector PMu1Lab(pla10,pla11,pla12,e1);
-  TLorentzVector PMu2Lab(pla20,pla21,pla22,e2);
+  TLorentzVector pMu1Lab(pla10,pla11,pla12,e1);
+  TLorentzVector pMu2Lab(pla20,pla21,pla22,e2);
   //
   // --- Obtain the dimuon parameters in the LAB frame
   //
-  TLorentzVector PDimuLab=PMu1Lab+PMu2Lab;
+  TLorentzVector pDimuLab=pMu1Lab+pMu2Lab;
   //
   // --- Translate the dimuon parameters in the dimuon rest frame
   //
-  TVector3 beta=(-1./PDimuLab.E())*PDimuLab.Vect();
-  TLorentzVector PMu1Dimu=PMu1Lab;
-  TLorentzVector PMu2Dimu=PMu2Lab;
-  TLorentzVector PProjDimu=PProjLab;
-  TLorentzVector PTargDimu=PTargLab;
-  PMu1Dimu.Boost(beta);
-  PMu2Dimu.Boost(beta);
-  PProjDimu.Boost(beta);
-  PTargDimu.Boost(beta);
+  TVector3 beta=(-1./pDimuLab.E())*pDimuLab.Vect();
+  TLorentzVector pMu1Dimu=pMu1Lab;
+  TLorentzVector pMu2Dimu=pMu2Lab;
+  TLorentzVector pProjDimu=pProjLab;
+  TLorentzVector pTargDimu=pTargLab;
+  pMu1Dimu.Boost(beta);
+  pMu2Dimu.Boost(beta);
+  pProjDimu.Boost(beta);
+  pTargDimu.Boost(beta);
   //
   // --- Determine the z axis for the CS angle 
   //
-  TVector3 zaxisCS=(((PProjDimu.Vect()).Unit())-((PTargDimu.Vect()).Unit())).Unit();
+  TVector3 zaxisCS=(((pProjDimu.Vect()).Unit())-((pTargDimu.Vect()).Unit())).Unit();
   //
   // --- Determine the CS angle (angle between mu+ and the z axis defined above)
   //
   Double_t cost;
-  if(Mu1Charge > 0) {
-    cost = zaxisCS.Dot((PMu1Dimu.Vect()).Unit());
+  if(mu1Charge > 0) {
+    cost = zaxisCS.Dot((pMu1Dimu.Vect()).Unit());
     // Theta CS is not properly defined for Like-Sign muons
-    if(Mu2Charge > 0 && cost<0) cost=-cost;
+    if(mu2Charge > 0 && cost<0) cost=-cost;
   } else { 
     // Theta CS is not properly defined for Like-Sign muons
-    cost = zaxisCS.Dot((PMu2Dimu.Vect()).Unit());
-    if(Mu2Charge < 0 && cost<0) cost=-cost;
+    cost = zaxisCS.Dot((pMu2Dimu.Vect()).Unit());
+    if(mu2Charge < 0 && cost<0) cost=-cost;
   }
   return cost;
 }
@@ -277,103 +360,114 @@ Double_t AliAODDimuon::CostCS(){
 //______________________________________________________________________________
 // Calculation the Helicity polarization angle (adapted from code by R. Arnaldi)
 Double_t AliAODDimuon::CostHe(){
+  // Cosinus of the polar decay angle in the Helicity reference frame
   if(CheckPointers())return -999999999;
-  if(ei==0){
+  if(fEi==0){
     printf("Pointer to MuonHeader not initialized\n");
     return -999999999;
   }
-  if(ei.GetObject()==0){
+  if(fEi.GetObject()==0){
     printf("Can not get MuonHeader object\n");
     return -999999999;
   }
-  Double_t EBeam=((AliAODEventInfo*)ei.GetObject())->EBeam();
-  if(EBeam<=0){
-    printf("Can not compute costCS with EBeam=%f\n",EBeam);
+  Double_t ebeam=((AliAODEventInfo*)fEi.GetObject())->EBeam();
+  if(ebeam<=0){
+    printf("Can not compute costCS with EBeam=%f\n",ebeam);
     return -999999999;
   }
-  Double_t PBeam=TMath::Sqrt(EBeam*EBeam-MProton*MProton);
-  Double_t pla10=((AliAODTrack*)mu[0].GetObject())->Px();
-  Double_t pla11=((AliAODTrack*)mu[0].GetObject())->Py();
-  Double_t pla12=((AliAODTrack*)mu[0].GetObject())->Pz();
-  Double_t e1=((AliAODTrack*)mu[0].GetObject())->E();
-  Double_t Mu1Charge=((AliAODTrack*)mu[0].GetObject())->Charge();
-  Double_t pla20=((AliAODTrack*)mu[1].GetObject())->Px();
-  Double_t pla21=((AliAODTrack*)mu[1].GetObject())->Py();
-  Double_t pla22=((AliAODTrack*)mu[1].GetObject())->Pz();
-  Double_t e2=((AliAODTrack*)mu[1].GetObject())->E();
-  Double_t Mu2Charge=((AliAODTrack*)mu[1].GetObject())->Charge();
+  Double_t pbeam=TMath::Sqrt(ebeam*ebeam-fMProton*fMProton);
+  Double_t pla10=((AliAODTrack*)fMu[0].GetObject())->Px();
+  Double_t pla11=((AliAODTrack*)fMu[0].GetObject())->Py();
+  Double_t pla12=((AliAODTrack*)fMu[0].GetObject())->Pz();
+  Double_t e1=((AliAODTrack*)fMu[0].GetObject())->E();
+  Double_t mu1Charge=((AliAODTrack*)fMu[0].GetObject())->Charge();
+  Double_t pla20=((AliAODTrack*)fMu[1].GetObject())->Px();
+  Double_t pla21=((AliAODTrack*)fMu[1].GetObject())->Py();
+  Double_t pla22=((AliAODTrack*)fMu[1].GetObject())->Pz();
+  Double_t e2=((AliAODTrack*)fMu[1].GetObject())->E();
+  Double_t mu2Charge=((AliAODTrack*)fMu[1].GetObject())->Charge();
 
   // Fill the Lorentz vector for projectile and target
   // For the moment we consider no crossing angle
   // Projectile runs towards the MUON arm
-  TLorentzVector PProjLab(0.,0.,-PBeam,EBeam); // projectile
-  TLorentzVector PTargLab(0.,0., PBeam,EBeam); // target
+  TLorentzVector pProjLab(0.,0.,-pbeam,ebeam); // projectile
+  TLorentzVector pTargLab(0.,0., pbeam,ebeam); // target
   //
   // --- Get the muons parameters in the LAB frame
   //
-  TLorentzVector PMu1Lab(pla10,pla11,pla12,e1);
-  TLorentzVector PMu2Lab(pla20,pla21,pla22,e2);
+  TLorentzVector pMu1Lab(pla10,pla11,pla12,e1);
+  TLorentzVector pMu2Lab(pla20,pla21,pla22,e2);
   //
   // --- Obtain the dimuon parameters in the LAB frame
   //
-  TLorentzVector PDimuLab=PMu1Lab+PMu2Lab;
+  TLorentzVector pDimuLab=pMu1Lab+pMu2Lab;
   //
   // --- Translate the dimuon parameters in the dimuon rest frame
   //
-  TVector3 beta=(-1./PDimuLab.E())*PDimuLab.Vect();
-  TLorentzVector PMu1Dimu=PMu1Lab;
-  TLorentzVector PMu2Dimu=PMu2Lab;
-  PMu1Dimu.Boost(beta);
-  PMu2Dimu.Boost(beta);
+  TVector3 beta=(-1./pDimuLab.E())*pDimuLab.Vect();
+  TLorentzVector pMu1Dimu=pMu1Lab;
+  TLorentzVector pMu2Dimu=pMu2Lab;
+  pMu1Dimu.Boost(beta);
+  pMu2Dimu.Boost(beta);
   //
   // --- Translate the dimuon parameters in the CM frame
   //
-  TLorentzVector PDimuCM; //CM frame
+  TLorentzVector pDimuCM; //CM frame
   TVector3 beta2;
-  beta2=(-1./(MProton+PProjLab.E()))*PProjLab.Vect();
-  PDimuCM=PDimuLab;
-  PDimuCM.Boost(beta2);
+  beta2=(-1./(fMProton+pProjLab.E()))*pProjLab.Vect();
+  pDimuCM=pDimuLab;
+  pDimuCM.Boost(beta2);
   //
-  // --- Determine the z axis for the calculation of the polarization angle (i.e. the direction of the dimuon in the CM system)
+  // --- Determine the z axis for the calculation of the polarization angle
+  // (i.e. the direction of the dimuon in the CM system)
   //
   TVector3 zaxis;
-  zaxis=(PDimuCM.Vect()).Unit();
+  zaxis=(pDimuCM.Vect()).Unit();
   //
-  // --- Calculation of the polarization angle (Kharzeev) (angle between mu+ and the z axis defined above)
+  // --- Calculation of the polarization angle (Helicity)
+  // (angle between mu+ and the z axis defined above)
   //
   Double_t cost;
-  if(Mu1Charge > 0) {
-    cost = zaxis.Dot((PMu1Dimu.Vect()).Unit());
-    // Theta Kharzeev is not properly defined for Like-Sign muons
-    if(Mu2Charge > 0 && cost<0) cost=-cost;
+  if(mu1Charge > 0) {
+    cost = zaxis.Dot((pMu1Dimu.Vect()).Unit());
+    // Theta Helicity is not properly defined for Like-Sign muons
+    if(mu2Charge > 0 && cost<0) cost=-cost;
   } else { 
-    cost = zaxis.Dot((PMu2Dimu.Vect()).Unit());
-    // Theta Kharzeev is not properly defined for Like-Sign muons
-    if(Mu2Charge < 0 && cost<0) cost=-cost;
+    cost = zaxis.Dot((pMu2Dimu.Vect()).Unit());
+    // Theta Helicity is not properly defined for Like-Sign muons
+    if(mu2Charge < 0 && cost<0) cost=-cost;
   }  
   return cost;
 }
 
+//______________________________________________________________________________
 Int_t AliAODDimuon::AnyPt(){
+  // Test if the two muons match two trigger tracks
   if(this->CheckPointers())return 0;
-  return (((AliAODTrack*)mu[0].GetObject())->MatchTriggerAnyPt())&&
-         (((AliAODTrack*)mu[0].GetObject())->MatchTriggerAnyPt());
+  return (((AliAODTrack*)fMu[0].GetObject())->MatchTriggerAnyPt())&&
+         (((AliAODTrack*)fMu[0].GetObject())->MatchTriggerAnyPt());
 }
 
+//______________________________________________________________________________
 Int_t AliAODDimuon::LowPt(){
+  // Test if the two muons match two trigger tracks with a "Low Pt" cut
   if(this->CheckPointers())return 0;
-  return (((AliAODTrack*)mu[0].GetObject())->MatchTriggerLowPt())&&
-         (((AliAODTrack*)mu[0].GetObject())->MatchTriggerLowPt());
+  return (((AliAODTrack*)fMu[0].GetObject())->MatchTriggerLowPt())&&
+         (((AliAODTrack*)fMu[0].GetObject())->MatchTriggerLowPt());
 }
 
+//______________________________________________________________________________
 Int_t AliAODDimuon::HighPt(){
+  // Test if the two muons match two trigger tracks with a "High Pt" cut
   if(this->CheckPointers())return 0;
-  return (((AliAODTrack*)mu[0].GetObject())->MatchTriggerHighPt())&&
-         (((AliAODTrack*)mu[0].GetObject())->MatchTriggerHighPt());
+  return (((AliAODTrack*)fMu[0].GetObject())->MatchTriggerHighPt())&&
+         (((AliAODTrack*)fMu[0].GetObject())->MatchTriggerHighPt());
 }
 
+//______________________________________________________________________________
 Double_t AliAODDimuon::MaxChi2Match(){
+  // Maximum matching Chi2 between track and trigger track
   if(this->CheckPointers())return -999999999;
-  return TMath::Max((((AliAODTrack*)mu[0].GetObject())->GetChi2MatchTrigger()),
-                    (((AliAODTrack*)mu[0].GetObject())->GetChi2MatchTrigger()));
+  return TMath::Max((((AliAODTrack*)fMu[0].GetObject())->GetChi2MatchTrigger()),
+                    (((AliAODTrack*)fMu[0].GetObject())->GetChi2MatchTrigger()));
 }
index 9b5ce30..4c9ea59 100644 (file)
@@ -1,33 +1,43 @@
 #ifndef AliAODDimuon_H
 #define AliAODDimuon_H
 
-/* AliAODDimuon: a class for AODs for the MUON Arm of the ALICE Experiment
- * Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
- * INFN of Torino - Italy
- */
+// AliAODDimuon: a class for AODs for the MUON Arm of the ALICE Experiment
+// Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
+// INFN of Torino - Italy
+//
+// The class defines a dimuon pair object from two AliAODTrack objects.
+// AliAODDimuon objects are supposed to be added to the AliAODEvent structure
+// during analysis. They would then allow to calculate the dimuon-related
+// kinematic variables with a minimal disk occupancy.
+// The payload of the class has been reduced to two pointers to the two
+// tracks with the addition of a pointer to the AliAODEventInfo. An instance of
+// this class has also to be added to the AliAODEvent structure to provide
+// additional information that is specific to MUON and therefore has not been
+// included into the AOD header.
+// Two transient data members are not stored on file as they can be recomputed
+// at runtime.
+//
 
-/* 2007/07/07 v0.00 Initial version */
-/* 2007/12/06 v0.01 Introduction of AliAODEventInfo */
-/* 2007/12/18 v0.02 Corrected CostCS for Like-Sign, added CostKh, CostHe and xf*/
+// 2007/07/07 v1.00 Initial version
+// 2007/12/06 v1.01 Introduction of AliAODEventInfo
+// 2007/12/18 v1.02 Corrected CostCS for Like-Sign, added CostKh, CostHe and xf
+// 2008/02/01 v1.03 Apply coding conventions
 
 #include "TRef.h"
 #include "AliVParticle.h"
-#include "TLorentzVector.h"
 #include "AliAODTrack.h"
 #include "AliAODEvent.h"
 #include "AliAODEventInfo.h"
 
+class TLorentzVector;
+
 class AliAODDimuon: public AliVParticle {
 public:
   AliAODDimuon();
   AliAODDimuon(const AliAODDimuon& dimu);
-  AliAODDimuon(TObject *mu0, TObject *mu1, TObject *evpoint=0);
-  ~AliAODDimuon();
-
-  // Data members
-  TRef mu[2];  // Pointers to the reconstructed muons
-  TRef ei;     // Pointer to the EventInfo object
-  TLorentzVector *p; //! TLorentzVector of dimuon momentum (not stored into file)
+  AliAODDimuon &operator=(const AliAODDimuon& dimu);
+  AliAODDimuon(TObject *mu0, TObject *mu1, TObject *ei=0);
+  virtual ~AliAODDimuon();
 
   // Methods to access kinematics
   virtual Double_t Px() const;
@@ -61,11 +71,12 @@ public:
   Double_t Phi();
   Double_t Theta();
   Double_t M();
+  Double_t Mass();
   Double_t Eta();
   Double_t Y();
 
   // Added functions
-  Double_t xf();     // Feynman x
+  Double_t XF();     // Feynman x
   Double_t CostCS(); // Cosinus of the Collins-Soper polar decay angle
   Double_t CostHe(); // Cosinus of the Helicity polar decay angle
   Int_t AnyPt();
@@ -75,17 +86,29 @@ public:
   // PID
   virtual const Double_t *PID() const {return 0;} // return PID object (to be defined, still)
 
-  // Additional getters
-  AliAODTrack* GetMu(Int_t imu=0){return (imu==0||imu==1)&&(mu[imu]!=0) ? (AliAODTrack*)mu[imu].GetObject() : 0; } // Get a pointer to a muon
-  AliAODTrack* Mu(Int_t imu=0){return (imu==0||imu==1)&&(mu[imu]!=0) ? (AliAODTrack*)mu[imu].GetObject() : 0; } // Get a pointer to a muon
-  AliAODEventInfo* MuonHeader(){return (ei!=0) ? (AliAODEventInfo*)ei.GetObject() : 0; } // Get a pointer to the AliAODEventInfo
+  // Additional getters and setters
+  AliAODTrack* GetMu(Int_t imu=0) const {return (imu==0||imu==1)&&(fMu[imu]!=0) ? (AliAODTrack*)fMu[imu].GetObject() : 0; } // Get a pointer to a muon
+  AliAODTrack* Mu(Int_t imu=0) const {return (imu==0||imu==1)&&(fMu[imu]!=0) ? (AliAODTrack*)fMu[imu].GetObject() : 0; } // Get a pointer to a muon
+  AliAODEventInfo* GetEventInfo() const {return (fEi!=0) ? (AliAODEventInfo*)fEi.GetObject() : 0; } // Get a pointer to the AliAODEventInfo
+  AliAODEventInfo* GetEi() const { return (fEi!=0) ? (AliAODEventInfo*)fEi.GetObject() : 0; }
+  AliAODEventInfo* Ei() const { return (fEi!=0) ? (AliAODEventInfo*)fEi.GetObject() : 0; }
 
-  // Useful constants
-  Double_t MProton; //! Proton mass (not stored into file)
+  void SetEi(AliAODEventInfo *ei){ fEi=ei; }
+  void SetMu(Int_t imu=0, AliAODTrack *mu=0);
+  void SetMuons(AliAODTrack *mu0=0, AliAODTrack *mu1=0);
 
 private:
   Int_t CheckPointers() const;
   void BookP();
+
+  // Data members
+  TRef fMu[2]; // Pointers to the reconstructed muons
+  TRef fEi;    // Pointer to the EventInfo object
+  TLorentzVector *fP; //! TLorentzVector of dimuon momentum (not stored into file)
+
+  // Useful constants
+  Double_t fMProton; //! Proton mass (not stored into file)
+
   ClassDef(AliAODDimuon,1)  // AliAODDimuon track
 };
 
index 1063c87..9ce2102 100644 (file)
@@ -1,9 +1,18 @@
-/* AliAODEventInfo: a class for AODs for the MUON Arm of the ALICE Experiment
- * Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
- * INFN of Torino - Italy
- */
+// AliAODEventInfo: a class for AODs for the MUON Arm of the ALICE Experiment
+// Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
+// INFN of Torino - Italy
+//
+// This class provides additional information about the AliAODEvent, some
+// of this is specific to MUON. The information stored in this class will 
+// follow the evolution of the framework (i.e. some data members  may be 
+// moved into the header in the future).
+// Currently it stores the beam energy and the information needed to decode
+// the trigger pattern (which are the bits corresponding to the different
+// muon triggers).
+//
 
 #include "AliAODEventInfo.h"
+#include "AliAODHeader.h"
 #define AliAODEventInfo_CXX
 
 // ************************************************************************** //
@@ -11,20 +20,23 @@ ClassImp(AliAODEventInfo)
 
 //______________________________________________________________________________
 AliAODEventInfo::AliAODEventInfo():fBeamEnergy(0),
-       fMUON_Single_LPt_L0(0),fMUON_Single_HPt_L0(0),fMUON_Like_LPt_L0(0),
-       fMUON_Like_HPt_L0(0),fMUON_Unlike_LPt_L0(0),fMUON_Unlike_HPt_L0(0),
-       ev(0),ei(this),he(0),tr(0),di(0)
+       fMuonSingleLPtL0(0),fMuonSingleHPtL0(0),fMuonLikeLPtL0(0),
+       fMuonLikeHPtL0(0),fMuonUnlikeLPtL0(0),fMuonUnlikeHPtL0(0),
+       fEv(0),fEi(this),fHe(0),fTr(0),fDi(0)
 {
+  // Default constructor
 }
 
 //______________________________________________________________________________
 AliAODEventInfo::~AliAODEventInfo()
 {
+  // Default destructor
 }
 
 //______________________________________________________________________________
-Bool_t AliAODEventInfo::IsHeaderAccessible(Char_t *msg){
-  if(he!=0){
+Bool_t AliAODEventInfo::IsHeaderAccessible(Char_t *msg) const {
+  // Tests if the header pointer is set
+  if(fHe!=0){
     return 1;
   }else{
     if(msg)printf("Error! Header is not accessible: %s",msg);
@@ -33,49 +45,68 @@ Bool_t AliAODEventInfo::IsHeaderAccessible(Char_t *msg){
 }
 
 //______________________________________________________________________________
-Bool_t AliAODEventInfo::MUON_Single_LPt_L0(){
-  if(IsHeaderAccessible("MUON_Single_LPt_L0"))
-    return ((((AliAODHeader*)he.GetObject())->GetTriggerMask())>>fMUON_Single_LPt_L0)&0x1;
+void AliAODEventInfo::SelectTriggerBits(UChar_t muonSingleLPtL0,
+    UChar_t muonSingleHPtL0,UChar_t muonLikeLPtL0, UChar_t muonLikeHPtL0,
+    UChar_t muonUnlikeLPtL0, UChar_t muonUnlikeHPtL0){
+  // Define which bit in the trigger pattern corresponds to the given trigger condition 
+  fMuonSingleLPtL0=muonSingleLPtL0;
+  fMuonSingleHPtL0=muonSingleHPtL0;
+  fMuonLikeLPtL0=muonLikeLPtL0;  
+  fMuonLikeHPtL0=muonLikeHPtL0;  
+  fMuonUnlikeLPtL0=muonUnlikeLPtL0;
+  fMuonUnlikeHPtL0=muonUnlikeHPtL0;
+}
+
+//______________________________________________________________________________
+Bool_t AliAODEventInfo::MuonSingleLPtL0() const {
+  // Test if the event fired MUON_Single_LPt_L0
+  if(IsHeaderAccessible("MuonSingleLPtL0"))
+    return ((((AliAODHeader*)fHe.GetObject())->GetTriggerMask())>>fMuonSingleLPtL0)&0x1;
   else
     return 0;
 }
 
-//______________________________________________________________________________
-Bool_t AliAODEventInfo::MUON_Single_HPt_L0(){
-  if(IsHeaderAccessible("MUON_Single_HPt_L0"))
-    return ((((AliAODHeader*)he.GetObject())->GetTriggerMask())>>fMUON_Single_HPt_L0)&0x1;
+//__________________________________________
+Bool_t AliAODEventInfo::MuonSingleHPtL0() const {
+  // Test if the event fired MUON_Single_HPt_L0
+  if(IsHeaderAccessible("MuonSingleHPtL0"))
+    return ((((AliAODHeader*)fHe.GetObject())->GetTriggerMask())>>fMuonSingleHPtL0)&0x1;
   else
     return 0;
 }
 
-//______________________________________________________________________________
-Bool_t AliAODEventInfo::MUON_Like_LPt_L0(){
-  if(IsHeaderAccessible("MUON_Like_LPt_L0"))
-    return ((((AliAODHeader*)he.GetObject())->GetTriggerMask())>>fMUON_Like_LPt_L0)&0x1;
+//__________________________________________
+Bool_t AliAODEventInfo::MuonLikeLPtL0() const {
+  // Test if the event fired MUON_Like_LPt_L0
+  if(IsHeaderAccessible("MuonLikeLPtL0"))
+    return ((((AliAODHeader*)fHe.GetObject())->GetTriggerMask())>>fMuonLikeLPtL0)&0x1;
   else
     return 0;
 }
 
-//______________________________________________________________________________
-Bool_t AliAODEventInfo::MUON_Like_HPt_L0(){
-  if(IsHeaderAccessible("MUON_Like_HPt_L0"))
-    return ((((AliAODHeader*)he.GetObject())->GetTriggerMask())>>fMUON_Like_HPt_L0)&0x1;
+//__________________________________________
+Bool_t AliAODEventInfo::MuonLikeHPtL0() const {
+  // Test if the event fired MUON_Like_HPt_L0
+  if(IsHeaderAccessible("MuonLikeHPtL0"))
+    return ((((AliAODHeader*)fHe.GetObject())->GetTriggerMask())>>fMuonLikeHPtL0)&0x1;
   else
     return 0;
 }
 
-//______________________________________________________________________________
-Bool_t AliAODEventInfo::MUON_Unlike_LPt_L0(){
-  if(IsHeaderAccessible("MUON_Unlike_LPt_L0"))
-    return ((((AliAODHeader*)he.GetObject())->GetTriggerMask())>>fMUON_Unlike_LPt_L0)&0x1;
+//__________________________________________
+Bool_t AliAODEventInfo::MuonUnlikeLPtL0() const {
+  // Test if the event fired MUON_Unlike_LPt_L0
+  if(IsHeaderAccessible("MuonUnlikeLPtL0"))
+    return ((((AliAODHeader*)fHe.GetObject())->GetTriggerMask())>>fMuonUnlikeLPtL0)&0x1;
   else
     return 0;
 }
 
-//______________________________________________________________________________
-Bool_t AliAODEventInfo::MUON_Unlike_HPt_L0(){
-  if(IsHeaderAccessible("MUON_Unlike_HPt_L0"))
-    return ((((AliAODHeader*)he.GetObject())->GetTriggerMask())>>fMUON_Unlike_HPt_L0)&0x1;
+//__________________________________________
+Bool_t AliAODEventInfo::MuonUnlikeHPtL0() const {
+  // Test if the event fired MUON_Unlike_HPt_L0
+  if(IsHeaderAccessible("MuonUnlikeHPtL0"))
+    return ((((AliAODHeader*)fHe.GetObject())->GetTriggerMask())>>fMuonUnlikeHPtL0)&0x1;
   else
     return 0;
 }
index c2d2378..7ac7688 100644 (file)
@@ -1,4 +1,3 @@
-#include "AliAODHeader.h"
 #include "TClonesArray.h"
 
 #ifndef AliAODEventInfo_H
@@ -6,51 +5,90 @@
 
 #include "AliAODEvent.h"
 
+class AliAODHeader;
 
-/* AliAODEventInfo: a class for AODs for the MUON Arm of the ALICE Experiment
- * Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
- * INFN of Torino - Italy
- */
+// AliAODEventInfo: a class for AODs for the MUON Arm of the ALICE Experiment
+// Author: P. Cortese, Universita' del Piemonte Orientale in Alessandria and
+// INFN of Torino - Italy
+//
+// This class provides additional information about the AliAODEvent, some
+// of this is specific to MUON. The information stored in this class will 
+// follow the evolution of the framework (i.e. some data members  may be 
+// moved into the header in the future).
+//
+//
 
-/* 2007/11/06 v0.00 Initial version */
-/* 2007/12/18 v0.01 More compact information for what regards trigger info */
+// 2007/11/06 v1.00 Initial version
+// 2007/12/18 v1.01 More compact information for what regards trigger info
+// 2008/02/01 v1.02 Apply coding conventions
 
 class AliAODEventInfo : public TNamed {
 public:
   AliAODEventInfo();
   ~AliAODEventInfo();
 
-  // Missing in AliAODHeader and added here
-  Double_t fBeamEnergy; // Add beam energy not present in AliAODHeader
-  UChar_t fMUON_Single_LPt_L0; // Decode trigger info
-  UChar_t fMUON_Single_HPt_L0; // Decode trigger info
-  UChar_t fMUON_Like_LPt_L0;   // Decode trigger info
-  UChar_t fMUON_Like_HPt_L0;   // Decode trigger info
-  UChar_t fMUON_Unlike_LPt_L0; // Decode trigger info
-  UChar_t fMUON_Unlike_HPt_L0; // Decode trigger info
-
   void SetBeamEnergy(Double_t BeamEnergy){ fBeamEnergy=BeamEnergy; };
-  Double_t EBeam(){ return fBeamEnergy; };
-  Double_t SqrtS(){ return 2*fBeamEnergy; };
-
-  // Data members and functions that provide automatic access
-  TRef ev; // Event
-  TRef ei; // EventInfo
-  TRef he; // Header
-  TRef tr; // Tracks
-  TRef di; // Dimuons
-  Bool_t IsHeaderAccessible(Char_t *msg=0);
+  Double_t EBeam() const { return fBeamEnergy; };
+  Double_t SqrtS() const { return 2*fBeamEnergy; };
 
   // -- Trigger information (to be updated in future)
-  Bool_t MUON_Single_LPt_L0();
-  Bool_t MUON_Single_HPt_L0();
-  Bool_t MUON_Like_LPt_L0();
-  Bool_t MUON_Like_HPt_L0();
-  Bool_t MUON_Unlike_LPt_L0();
-  Bool_t MUON_Unlike_HPt_L0();
-
-  Int_t         GetNDimuons()           const { return (di!=0) ? ((TClonesArray*)di.GetObject())->GetSize() : 0;}
-  Int_t         NDimu()           { return GetNDimuons();}
+  void SelectTriggerBits(UChar_t muonSingleLPtL0, UChar_t muonSingleHPtL0,
+                        UChar_t muonLikeLPtL0, UChar_t muonLikeHPtL0,
+                        UChar_t muonUnlikeLPtL0, UChar_t muonUnlikeHPtL0);
+
+  UChar_t GetBitSingleLPtL0() const { return fMuonSingleLPtL0; }
+  UChar_t GetBitSingleHPtL0() const { return fMuonSingleHPtL0; }
+  UChar_t GetBitLikeLPtL0() const { return fMuonLikeLPtL0; }
+  UChar_t GetBitLikeHPtL0() const { return fMuonLikeHPtL0; }
+  UChar_t GetBitUnlikeLPtL0() const { return fMuonUnlikeLPtL0; }
+  UChar_t GetBitUnlikeHPtL0() const { return fMuonUnlikeHPtL0; }
+
+  Bool_t MuonSingleLPtL0() const; // Test trigger pattern for MUON_Single_LPt_L0
+  Bool_t MuonSingleHPtL0() const; // Test trigger pattern for MUON_Single_HPt_L0
+  Bool_t MuonLikeLPtL0() const; // Test trigger pattern for MUON_Like_LPt_L0
+  Bool_t MuonLikeHPtL0() const; // Test trigger pattern for MUON_Like_HPt_L0
+  Bool_t MuonUnlikeLPtL0() const; // Test trigger pattern for MUON_Unlike_LPt_L0
+  Bool_t MuonUnlikeHPtL0() const; // Test trigger pattern for MUON_Unlike_HPt_L0
+
+  Int_t GetNDimuons() const { return (fDi!=0) ? ((TClonesArray*)fDi.GetObject())->GetSize() : 0;}
+  Int_t NDimu() const { return GetNDimuons();}
+
+  // Pointers
+  void SetEv(AliAODEvent *ev){ fEv=ev; }
+  void SetEi(AliAODEventInfo *ei){ fEi=ei; }
+  void SetHe(AliAODHeader *he){ fHe=he; }
+  void SetTr(TClonesArray *tr){ fTr=tr; }
+  void SetDi(TClonesArray *di){ fDi=di; }
+
+  AliAODEvent *GetEv() { return (fEv!=0) ? (AliAODEvent*)fEv.GetObject() : 0; }
+  AliAODEventInfo* GetEi() { return (fEi!=0) ? (AliAODEventInfo*)fEi.GetObject() : 0; }
+  TClonesArray *GetDi() { return (fDi!=0) ? (TClonesArray*)fDi.GetObject() : 0; } // Get dimuon array
+
+  AliAODEvent *Ev() { return (fEv!=0) ? (AliAODEvent*)fEv.GetObject() : 0; }
+  TClonesArray *Di() { return (fDi!=0) ? (TClonesArray*)fDi.GetObject() : 0; } // Get dimuon array
+  AliAODEventInfo* Ei() { return (fEi!=0) ? (AliAODEventInfo*)fEi.GetObject() : 0; }
+
+//  AliAODHeader *GetHe() { return (fHe!=0) ? (AliAODHeader*)fHe.GetObject() : 0; }
+//  AliAODTrack *GetTr();
+
+  Bool_t IsHeaderAccessible(Char_t *msg=0) const;
+
+  protected:
+  // Missing in AliAODHeader and added here
+  Double_t fBeamEnergy; // Add beam energy not present in AliAODHeader
+  UChar_t fMuonSingleLPtL0; // Decode trigger info
+  UChar_t fMuonSingleHPtL0; // Decode trigger info
+  UChar_t fMuonLikeLPtL0;   // Decode trigger info
+  UChar_t fMuonLikeHPtL0;   // Decode trigger info
+  UChar_t fMuonUnlikeLPtL0; // Decode trigger info
+  UChar_t fMuonUnlikeHPtL0; // Decode trigger info
+
+  // Data members to provide automatic access
+  TRef fEv; // Event
+  TRef fEi; // EventInfo
+  TRef fHe; // Header
+  TRef fTr; // Tracks
+  TRef fDi; // Dimuons
 
   ClassDef(AliAODEventInfo,1)  // Additional header for MUON arm
 };
index 54fad26..c016fc3 100644 (file)
@@ -1,7 +1,10 @@
 #define AliAnalysisTaskMuonAODfromGeneral_cxx
 
 // 19 Nov 2007
-// Class implementation for the specific dimuon AOD generation from a general AOD
+// Class implementation for the specific muon AOD generation
+// Extracts only muon tracks from a general AOD and builds dimuons
+// Livio Bianchi, Universita' di Torino
+
 
 #include "TTree.h"
 #include "TROOT.h"
@@ -11,6 +14,7 @@
 #include "TRandom.h"
 
 #include "AliAODEvent.h"
+#include "AliAnalysisTask.h"
 #include "AliAnalysisTaskMuonAODfromGeneral.h"
 #include "AliAODHandler.h"
 #include "AliAnalysisManager.h"
@@ -171,17 +175,12 @@ void AliAnalysisTaskMuonAODfromGeneral::Exec(Option_t *) {
   }
   
   fInfos->SetBeamEnergy(fBeamEnergy);
-  fInfos->ev=fNewAOD;
-  fInfos->ei=fInfos;
-  fInfos->he=header;
-  fInfos->tr=fNewAOD->GetTracks();
-  fInfos->di=fDimuons;
-  fInfos->fMUON_Single_LPt_L0=0;
-  fInfos->fMUON_Single_HPt_L0=1;
-  fInfos->fMUON_Like_LPt_L0=2; 
-  fInfos->fMUON_Like_HPt_L0=3;  
-  fInfos->fMUON_Unlike_LPt_L0=4;
-  fInfos->fMUON_Unlike_HPt_L0=5;
+  fInfos->SetEv(fNewAOD);
+  fInfos->SetEi(fInfos);
+  fInfos->SetHe(header);
+  fInfos->SetTr(fNewAOD->GetTracks());
+  fInfos->SetDi(fDimuons);
+  fInfos->SelectTriggerBits(0,1,2,3,4,5);
   if(ExistMuon) ft->Fill();
   ncall++;
 
index 3b06ba1..070a868 100644 (file)
@@ -17,7 +17,7 @@
 
 class AliAnalysisTaskMuonAODfromGeneral : public AliAnalysisTask {
  public:
-  AliAnalysisTaskMuonAODfromGeneral() : AliAnalysisTask(), fOrgAOD(0), fNewAOD(0), ft(0), fBeamEnergy(0) {}
+  AliAnalysisTaskMuonAODfromGeneral() : AliAnalysisTask(), fInfos(0), fDimuons(0), fChain(0), fOrgAOD(0), fNewAOD(0), ft(0), fBeamEnergy(0) {}
   AliAnalysisTaskMuonAODfromGeneral(const char *name, Double_t BeamEnergy);
   virtual ~AliAnalysisTaskMuonAODfromGeneral() {}