Update Kink Analysis from Evi Ganoti

diff --git a/PWG2/CMake_libPWG2kink.txt b/PWG2/CMake_libPWG2kink.txt
index a100b6f2423edfb0a921d70e0eff71f4f0775ea5..4f1c3bcd09c375aa96f379dfe0fc2b0b17f5ea22 100644 (file)
--- a/PWG2/CMake_libPWG2kink.txt
+++ b/PWG2/CMake_libPWG2kink.txt
@@ -3,7 +3,8 @@
 set(SRCS
     KINK/AliAnalysisKinkESDMC.cxx
     KINK/AliResonanceKinkLikeSign.cxx
-    KINK/AliResonanceKinkPID.cxx
+    KINK/AliResonanceKink.cxx
+    KINK/AliAnalysisTaskKinkResonance.cxx
 )
 
 # fill list of header files from list of source files

diff --git a/PWG2/KINK/AliAnalysisTaskKinkResonance.cxx b/PWG2/KINK/AliAnalysisTaskKinkResonance.cxx
new file mode 100644 (file)
index 0000000..c71c2e1
--- /dev/null
+++ b/PWG2/KINK/AliAnalysisTaskKinkResonance.cxx
@@ -0,0 +1,127 @@
+/**************************************************************************
+ * Author: Paraskevi Ganoti, University of Athens (pganoti@phys.uoa.gr)   *
+ * 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.                  *
+ **************************************************************************/
+ 
+//----------------------------------------------------------------------------------------------------------------
+//                        class AliAnalysisTaskKinkResonance
+//        Example of an analysis task for reconstructing resonances having at least one kaon-kink in their decay 
+//        products. It provides basic plots as well as plots helping to calculate the corrections.
+//        Usage: To analyse a resonance having a kaon in its decay products, one has to modify the integer 
+//        variables resonancePDG, daughter1 and daughter2 accordingly as well as daughter1Mass  and daughter2Mass.
+//        Also, depending on the analysis mode (ESD or MC), fAnalysisType in the constructor must also be changed 
+//-----------------------------------------------------------------------------------------------------------------
+#include "TCanvas.h"
+#include "TChain.h"
+#include "TTree.h"
+#include "TH2D.h"
+
+#include "AliAnalysisTaskSE.h"
+#include "AliAnalysisManager.h"
+#include "AliESDInputHandler.h"
+#include "AliMCEventHandler.h"
+#include "AliMCEvent.h"
+#include "AliResonanceKink.h"
+#include "AliAnalysisTaskKinkResonance.h"
+
+ClassImp(AliAnalysisTaskKinkResonance)
+
+//_____________________________________________________________________________
+AliAnalysisTaskKinkResonance::AliAnalysisTaskKinkResonance() 
+  : AliAnalysisTaskSE(), fESD(0), fmcEventH(0), fList(0), fKinkResonance(0)
+
+{
+  // Constructor
+}
+
+//______________________________________________________________________________
+AliAnalysisTaskKinkResonance::AliAnalysisTaskKinkResonance(const char *name) 
+  : AliAnalysisTaskSE(name), fESD(0), fmcEventH(0), fList(0), fKinkResonance(0)
+
+{
+  // Constructor
+
+  // Define input and output slots here
+  // Input slot #0 works with a TChain
+  DefineInput(0, TChain::Class());
+  DefineOutput(1, TList::Class());
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskKinkResonance::ConnectInputData(Option_t *) 
+{
+  // Connect ESD or AOD here
+  // Called once
+  
+  TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
+  if (!tree) {
+    Printf("ERROR: Could not read chain from input slot 0");
+  } else {
+
+    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+
+    if (!esdH) {
+      Printf("ERROR: Could not get ESDInputHandler");
+    } else
+      fESD = esdH->GetEvent();
+      
+    AliMCEventHandler* eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
+    
+    if (!eventHandler) {
+       Printf("ERROR: Could not retrieve MC event handler");
+       return;
+     }
+
+     fmcEventH = eventHandler->MCEvent(); 
+  }
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskKinkResonance::CreateOutputObjects() 
+{
+  // Create histograms
+  // Called once
+  
+  fList=new TList();
+  fList= fKinkResonance->GetHistogramList();
+   
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskKinkResonance::Exec(Option_t *) 
+{
+  // Main loop
+  // Called for each event
+   
+   fKinkResonance->Analyse(fESD, fmcEventH);
+   
+   PostData(1, fList);
+   
+}      
+
+//________________________________________________________________________
+void AliAnalysisTaskKinkResonance::Terminate(Option_t *) 
+{
+  // Draw result to the screen 
+  // Called once at the end of the query
+  fList = dynamic_cast<TList*> (GetOutputData(1));
+
+  if (!fList) {
+    Printf("ERROR: fList not available");
+    return;
+  }
+  //TH1D* h=(TH1D *) fList->At(15);
+  //TCanvas *c1 = new TCanvas("AliAnalysisTaskKinkResonance","Pt MC",10,10,510,510);
+  //c1->cd(1);
+  //if (h) h->DrawCopy("E");
+
+}
+

diff --git a/PWG2/KINK/AliAnalysisTaskKinkResonance.h b/PWG2/KINK/AliAnalysisTaskKinkResonance.h
new file mode 100644 (file)
index 0000000..d62482d
--- /dev/null
+++ b/PWG2/KINK/AliAnalysisTaskKinkResonance.h
@@ -0,0 +1,45 @@
+#ifndef ALIANALYSISTASKKINKRESONANCE_H
+#define ALIANALYSISTASKKINKRESONANCE_H
+
+/*  See cxx source for full Copyright notice */
+
+//------------------------------------------------------------------------------
+//                   class AliAnalysisTaskKinkResonance
+//         This task is an example of an analysis task
+//        for analysing resonances having one kaon kink
+//Author: Paraskevi Ganoti, University of Athens (pganoti@phys.uoa.gr)
+//------------------------------------------------------------------------------
+
+class TList;
+class AliESDEvent;
+class AliMCEvent;
+class AliResonanceKink;
+class TH1D;
+
+class AliAnalysisTaskKinkResonance : public AliAnalysisTaskSE {
+ public:
+  AliAnalysisTaskKinkResonance();
+  AliAnalysisTaskKinkResonance(const char *name);
+  virtual ~AliAnalysisTaskKinkResonance() {}
+  
+  virtual void   ConnectInputData(Option_t *);
+  virtual void   CreateOutputObjects();
+  virtual void   Exec(Option_t *option);
+  virtual void   Terminate(Option_t *);
+  
+  void SetAnalysisKinkObject(AliResonanceKink * const kinkResonance) {
+    fKinkResonance=kinkResonance;}
+  
+ private:
+  AliESDEvent       *fESD;    //! ESD object
+  AliMCEvent        *fmcEventH;
+  TList             *fList; //! List 
+  AliResonanceKink  *fKinkResonance;
+  
+  AliAnalysisTaskKinkResonance(const AliAnalysisTaskKinkResonance&); // not implemented
+  AliAnalysisTaskKinkResonance& operator=(const AliAnalysisTaskKinkResonance&); // not implemented
+
+  ClassDef(AliAnalysisTaskKinkResonance, 1); // example of analysis
+};
+
+#endif

diff --git a/PWG2/KINK/AliResonanceKinkPID.cxx b/PWG2/KINK/AliResonanceKink.cxx
similarity index 68%
rename from PWG2/KINK/AliResonanceKinkPID.cxx
rename to PWG2/KINK/AliResonanceKink.cxx
index 3cd5f0be7170625cf89fd603b1ca2fd32f2b1201..6f8cf49bc47d002d98be0b7313d2a3f256db1781 100644 (file)
--- a/PWG2/KINK/AliResonanceKinkPID.cxx
+++ b/PWG2/KINK/AliResonanceKink.cxx
@@ -12,11 +12,11 @@
  **************************************************************************/
  
 //----------------------------------------------------------------------------------------------------------------
-//                        class AliResonanceKinkPID
+//                        class AliResonanceKink
 //        Example of an analysis task for reconstructing resonances having at least one kaon-kink in their decay 
 //        products. It provides basic plots as well as plots helping to calculate the corrections.
 //        Usage: To analyse a resonance having a kaon in its decay products, one has to modify the integer 
-//        variables resonancePDG, daughter1 and daughter2 accordingly as well as daughter1Mass  and daughter2Mass.
+//        variables resonancePDG, fdaughter1pdg and fdaughter2pdg accordingly as well as daughter1pdgMass  and daughter2pdgMass.
 //        Also, depending on the analysis mode (ESD or MC), fAnalysisType in the constructor must also be changed 
 //-----------------------------------------------------------------------------------------------------------------
 
@@ -28,93 +28,40 @@
 #include <TDatabasePDG.h>
 #include <TParticlePDG.h>
 #include "TF1.h"
-#include "AliAnalysisTaskSE.h"
-#include "AliAnalysisManager.h"
-
-#include "AliESDInputHandler.h"
-
+#include "TList.h"
+#include "TString.h"
 #include "AliMCEventHandler.h"
 #include "AliMCEvent.h"
-
-#include "AliResonanceKinkPID.h"
+#include "AliResonanceKink.h"
 #include "AliESDkink.h"
 #include "AliStack.h"
+#include "AliESDtrack.h"
+#include "AliESDEvent.h"
 
-ClassImp(AliResonanceKinkPID)
+ClassImp(AliResonanceKink)
 
 //________________________________________________________________________
-AliResonanceKinkPID::AliResonanceKinkPID() 
-  : AliAnalysisTaskSE(), fESD(0), fListOfHistos(0), fOpeningAngle(0), fInvariantMass(0), fInvMassTrue(0), fPhiBothKinks(0), fRecPt(0), fRecEta(0), fRecEtaPt(0), 
-  fSimPt(0), fSimEta(0), fSimEtaPt(0), fSimPtKink(0), fSimEtaKink(0),  fSimEtaPtKink(0), 
-  fhdr(0), fhdz(0), f1(0), f2(0), fAnalysisType("ESD"), fvtxz(0)
+AliResonanceKink::AliResonanceKink() 
+  : TObject(), fListOfHistos(0), fOpeningAngle(0), fInvariantMass(0), fInvMassTrue(0), fPhiBothKinks(0), fRecPt(0), fRecEta(0), fRecEtaPt(0), fSimPt(0), fSimEta(0), fSimEtaPt(0), fSimPtKink(0), fSimEtaKink(0),  fSimEtaPtKink(0), 
+  fhdr(0), fhdz(0), f1(0), f2(0), fAnalysisType(), fvtxz(0), fNbins(0), fLowX(0), fHighX(0), fdaughter1pdg(0), fdaughter2pdg(0), fresonancePDGcode(0)
 
 {
   // Constructor
 }
 
 //________________________________________________________________________
-AliResonanceKinkPID::AliResonanceKinkPID(const char *name) 
-  : AliAnalysisTaskSE(name), fESD(0), fListOfHistos(0), fOpeningAngle(0), fInvariantMass(0), fInvMassTrue(0), fPhiBothKinks(0), fRecPt(0), fRecEta(0), fRecEtaPt(0),
-  fSimPt(0), fSimEta(0), fSimEtaPt(0), fSimPtKink(0), fSimEtaKink(0),  fSimEtaPtKink(0), 
-  fhdr(0), fhdz(0), f1(0), f2(0), fAnalysisType("ESD"), fvtxz(0)
-
-{
-  // Constructor
-
-  // Define input and output slots here
-  // Input slot #0 works with a TChain
-  DefineInput(0, TChain::Class());
-  DefineOutput(1, TList::Class());
-}
-
-//________________________________________________________________________
-void AliResonanceKinkPID::ConnectInputData(Option_t *) 
-{
-  // Connect ESD or AOD here
-  // Called once
+AliResonanceKink::AliResonanceKink(Int_t nbins, Float_t nlowx, Float_t nhighx, Int_t daughter1, Int_t daughter2, Int_t resonancePDG) 
+  : TObject(), fListOfHistos(0), fOpeningAngle(0), fInvariantMass(0), fInvMassTrue(0), fPhiBothKinks(0), fRecPt(0), fRecEta(0), fRecEtaPt(0), fSimPt(0), fSimEta(0), fSimEtaPt(0), fSimPtKink(0), fSimEtaKink(0),  fSimEtaPtKink(0), 
+  fhdr(0), fhdz(0), f1(0), f2(0), fAnalysisType(), fvtxz(0), fNbins(nbins), fLowX(nlowx), fHighX(nhighx), fdaughter1pdg(daughter1), fdaughter2pdg(daughter2), fresonancePDGcode(resonancePDG)
 
-  TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
-  if (!tree) {
-    Printf("ERROR: Could not read chain from input slot 0");
-  } else {
-
-    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-
-    if (!esdH) {
-      Printf("ERROR: Could not get ESDInputHandler");
-    } else
-      fESD = esdH->GetEvent();
-  }
-}
-
-//________________________________________________________________________
-void AliResonanceKinkPID::CreateOutputObjects() 
 {
-  // Create histograms
-  // Called once
+   // Constructor
   
-   f1=new TF1("f1","((atan([0]*[1]*(1.0/(sqrt((x^2)*(1.0-([1]^2))-([0]^2)*([1]^2))))))*180.)/[2]",1.1,10.0);
-   f1->SetParameter(0,0.493677);
-   f1->SetParameter(1,0.9127037);
-   f1->SetParameter(2,TMath::Pi());
-
-   f2=new TF1("f2","((atan([0]*[1]*(1.0/(sqrt((x^2)*(1.0-([1]^2))-([0]^2)*([1]^2))))))*180.)/[2]",0.1,10.0);
-   f2->SetParameter(0,0.13957018);
-   f2->SetParameter(1,0.2731374);
-   f2->SetParameter(2,TMath::Pi());
-  
-   // OpenFile(1); Uncomment for proof analysis
    fOpeningAngle=new TH1D("fOpeningAngle"," ", 100,-1.0,1.0);
 
-   // for K*0(892)
-   fInvariantMass=new TH1D("fInvariantMass"," ", 60,0.6,1.2);
-   fInvMassTrue=new TH1D("fInvMassTrue"," ",60,0.6,1.2);
-   fPhiBothKinks=new TH1D("fPhiBothKinks"," ", 60,0.6,1.2);  // Not applicable for K*0
-
-   //for phi(1020)
-   //fInvariantMass=new TH1D("fInvariantMass"," ", 70,0.99,1.088);
-   //fInvMassTrue=new TH1D("fInvMassTrue"," ", 70,0.99,1.088);
-   //fPhiBothKinks=new TH1D("fPhiBothKinks"," ", 70,0.99,1.088);
+   fInvariantMass=new TH1D("fInvariantMass"," ",fNbins,fLowX,fHighX);
+   fInvMassTrue=new TH1D("fInvMassTrue"," ",fNbins,fLowX,fHighX);
+   fPhiBothKinks=new TH1D("fPhiBothKinks"," ",fNbins,fLowX,fHighX);  // Applicable for phi(1020)
 
    fRecPt=new TH1D("fRecPt"," ", 50,0.0,5.0);
    fRecEta=new TH1D("fRecEta"," ", 44,-1.1,1.1);
@@ -127,69 +74,143 @@ void AliResonanceKinkPID::CreateOutputObjects()
    fSimEtaPtKink=new TH2D("fSimEtaPtKink"," ", 50,0.0,5.0, 44,-1.1,1.1);                
    fhdr=new TH1D("fhdr"," ", 100,0.0,5.0);  
    fhdz=new TH1D("fhdz"," ", 100,0.0,5.0);
+   
+   f1=new TF1("f1","((atan([0]*[1]*(1.0/(sqrt((x^2)*(1.0-([1]^2))-([0]^2)*([1]^2))))))*180.)/[2]",1.1,10.0);
+   f1->SetParameter(0,0.493677);
+   f1->SetParameter(1,0.9127037);
+   f1->SetParameter(2,TMath::Pi());
+
+   f2=new TF1("f2","((atan([0]*[1]*(1.0/(sqrt((x^2)*(1.0-([1]^2))-([0]^2)*([1]^2))))))*180.)/[2]",0.1,10.0);
+   f2->SetParameter(0,0.13957018);
+   f2->SetParameter(1,0.2731374);
+   f2->SetParameter(2,TMath::Pi());
+   
    fvtxz=new TH1D("fvtxz"," ", 100,-20.0,20.0);
- 
-   fListOfHistos=new TList();
-  
-   fListOfHistos->Add(fOpeningAngle);
-   fListOfHistos->Add(fInvariantMass);
-   fListOfHistos->Add(fInvMassTrue);
-   fListOfHistos->Add(fPhiBothKinks);
-   fListOfHistos->Add(fRecPt);    
-   fListOfHistos->Add(fRecEta);   
-   fListOfHistos->Add(fRecEtaPt);    
-   fListOfHistos->Add(fSimPt);    
-   fListOfHistos->Add(fSimEta);   
-   fListOfHistos->Add(fSimEtaPt);     
-   fListOfHistos->Add(fSimPtKink);    
-   fListOfHistos->Add(fSimEtaKink);   
-   fListOfHistos->Add(fSimEtaPtKink);                                                           
-   fListOfHistos->Add(fhdr);
-   fListOfHistos->Add(fhdz);
-   fListOfHistos->Add(fvtxz);
 
 }
 
 //________________________________________________________________________
-void AliResonanceKinkPID::Exec(Option_t *) 
+AliResonanceKink:: ~AliResonanceKink()
 {
-  // Main loop
-  // Called for each event
+ //  Destructor
+ if(fOpeningAngle) delete fOpeningAngle;
+ if(fInvariantMass) delete fInvariantMass;
+ if(fInvMassTrue) delete fInvMassTrue;
+ if(fPhiBothKinks) delete fPhiBothKinks;
+ if(fRecPt) delete fRecPt;
+ if(fRecEta) delete fRecEta;
+ if(fRecEtaPt) delete fRecEtaPt;
+ if(fSimPt) delete fSimPt;
+ if(fSimEta) delete fSimEta;
+ if(fSimEtaPt) delete fSimEtaPt;
+ if(fSimPtKink) delete fSimPtKink;
+ if(fSimEtaKink) delete fSimEtaKink;
+ if(fSimEtaPtKink) delete fSimEtaPtKink;
+ if(fhdr) delete fhdr;
+ if(fhdz) delete fhdz;   
+ if(fvtxz) delete fvtxz;         
+}
+//________________________________________________________________________
+TList* AliResonanceKink::GetHistogramList()
+{
+  // Adding histograms to the list
+  fListOfHistos=new TList();
  
-   enum ResonanceType {kPhi=333, kKstar0=313, kLambda1520=3124};
-   enum DaughterType {kdaughterPion=211, kdaughterKaon=321, kdaughterProton=2212};
+  fListOfHistos->Add(fOpeningAngle);
+  fListOfHistos->Add(fInvariantMass);
+  fListOfHistos->Add(fInvMassTrue);
+  fListOfHistos->Add(fPhiBothKinks);
+  fListOfHistos->Add(fRecPt);    
+  fListOfHistos->Add(fRecEta);   
+  fListOfHistos->Add(fRecEtaPt);    
+  fListOfHistos->Add(fSimPt);    
+  fListOfHistos->Add(fSimEta);   
+  fListOfHistos->Add(fSimEtaPt);     
+  fListOfHistos->Add(fSimPtKink);    
+  fListOfHistos->Add(fSimEtaKink);   
+  fListOfHistos->Add(fSimEtaPtKink);                                                           
+  fListOfHistos->Add(fhdr);
+  fListOfHistos->Add(fhdz);
+  fListOfHistos->Add(fvtxz);
    
-   Int_t resonancePDG=kKstar0;
-  
-   Int_t daughter1=kdaughterKaon;
-   Int_t daughter2=kdaughterPion;
+  return fListOfHistos;
+}
+
+//________________________________________________________________________
+void AliResonanceKink::InitOutputHistograms(Int_t nbins, Float_t nlowx, Float_t nhighx)
+{
+  //  Initialisation of the output histograms
+  fNbins=nbins; 
+  fLowX=nlowx; 
+  fHighX=nhighx;
+    
+  fOpeningAngle=new TH1D("fOpeningAngle"," ", 100,-1.0,1.0);
+
+  fInvariantMass=new TH1D("fInvariantMass"," ",fNbins,fLowX,fHighX);
+  fInvMassTrue=new TH1D("fInvMassTrue"," ",fNbins,fLowX,fHighX);
+  fPhiBothKinks=new TH1D("fPhiBothKinks"," ",fNbins,fLowX,fHighX);  // Applicable for phi(1020)
+
+  fRecPt=new TH1D("fRecPt"," ", 50,0.0,5.0);
+  fRecEta=new TH1D("fRecEta"," ", 44,-1.1,1.1);
+  fRecEtaPt=new TH2D("fRecEtaPt"," ", 50,0.0,5.0, 44,-1.1,1.1); 
+  fSimPt=new TH1D("fSimPt"," ", 50,0.0,5.0);
+  fSimEta=new TH1D("fSimEta"," ", 44,-1.1,1.1); 
+  fSimEtaPt=new TH2D("fSimEtaPt"," ", 50,0.0,5.0, 44,-1.1,1.1);
+  fSimPtKink=new TH1D("fSimPtKink"," ", 50,0.0,5.0);
+  fSimEtaKink=new TH1D("fSimEtaKink"," ", 44,-1.1,1.1);
+  fSimEtaPtKink=new TH2D("fSimEtaPtKink"," ", 50,0.0,5.0, 44,-1.1,1.1);                
+  fhdr=new TH1D("fhdr"," ", 100,0.0,5.0);  
+  fhdz=new TH1D("fhdz"," ", 100,0.0,5.0);
    
-   Double_t daughter1Mass=TDatabasePDG::Instance()->GetParticle(kKPlus)->Mass();
-   Double_t daughter2Mass=TDatabasePDG::Instance()->GetParticle(kPiPlus)->Mass();
+  f1=new TF1("f1","((atan([0]*[1]*(1.0/(sqrt((x^2)*(1.0-([1]^2))-([0]^2)*([1]^2))))))*180.)/[2]",1.1,10.0);
+  f1->SetParameter(0,0.493677);
+  f1->SetParameter(1,0.9127037);
+  f1->SetParameter(2,TMath::Pi());
+
+  f2=new TF1("f2","((atan([0]*[1]*(1.0/(sqrt((x^2)*(1.0-([1]^2))-([0]^2)*([1]^2))))))*180.)/[2]",0.1,10.0);
+  f2->SetParameter(0,0.13957018);
+  f2->SetParameter(1,0.2731374);
+  f2->SetParameter(2,TMath::Pi());
    
-   AliMCEventHandler* eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
-   if (!eventHandler) {
-    Printf("ERROR: Could not retrieve MC event handler");
-    return;
-   }
-
-  AliMCEvent* mcEvent = eventHandler->MCEvent();
-  if (!mcEvent) {
-     Printf("ERROR: Could not retrieve MC event");
-     return;
+  fvtxz=new TH1D("fvtxz"," ", 100,-20.0,20.0);
+}
+  
+//________________________________________________________________________
+void AliResonanceKink::Analyse(AliESDEvent* esd, AliMCEvent* mcEvent) 
+{
+  // Main loop
+  // Called for each event
+  Int_t resonancePDGcode, antiresonancePDGcode;
+  
+  if (fdaughter1pdg==kdaughterKaon)  {
+    resonancePDGcode=fresonancePDGcode;
+    antiresonancePDGcode=-fresonancePDGcode;
   }
+  if (fdaughter1pdg!=kdaughterKaon)  {
+    resonancePDGcode=-fresonancePDGcode;
+    antiresonancePDGcode=fresonancePDGcode;
+  }  
+  if (fdaughter1pdg==fdaughter2pdg)  {
+    resonancePDGcode=fresonancePDGcode;
+    antiresonancePDGcode=fresonancePDGcode;
+  }  
 
-  Printf("MC particles: %d", mcEvent->GetNumberOfTracks());
-
-  if (!fESD) {
+   Double_t daughter1pdgMass=TDatabasePDG::Instance()->GetParticle(fdaughter1pdg)->Mass();
+   Double_t daughter2pdgMass=TDatabasePDG::Instance()->GetParticle(fdaughter2pdg)->Mass();
+   
+  if (!esd) {
     Printf("ERROR: fESD not available");
     return;
   }  
 
+    if (!mcEvent) {
+    Printf("ERROR: mcEvent not available");
+    return;
+  }  
+
   AliStack* stack=mcEvent->Stack();
 
   if(fAnalysisType == "MC") {
-    
   for (Int_t iMc = 0; iMc < stack->GetNprimary(); ++iMc)
   {
     TParticle* particle = stack->Particle(iMc);
@@ -200,7 +221,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
       continue;
     }
 
-     if(TMath::Abs(particle->GetPdgCode())==resonancePDG) {
+     if(TMath::Abs(particle->GetPdgCode())==fresonancePDGcode) {
        Int_t firstD=particle->GetFirstDaughter();
        Int_t lastD=particle->GetLastDaughter();
        TParticle *daughterParticle1=stack->Particle(firstD);
@@ -233,22 +254,19 @@ void AliResonanceKinkPID::Exec(Option_t *)
   else 
   
   if(fAnalysisType == "ESD") {
-  
-  const AliESDVertex* vertex = GetEventVertex(fESD);
+  const AliESDVertex* vertex = GetEventVertex(esd);
   if(!vertex) return;
   Double_t vtx[3];
   vertex->GetXYZ(vtx);
   fvtxz->Fill(vtx[2]);
-  
   Double_t ptrackpos[3], ptrackneg[3];
   
   TLorentzVector p4pos, anp4pos;
   TLorentzVector p4neg, anp4neg;
   TLorentzVector p4comb, anp4comb;
   
-  
-  for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
-    AliESDtrack* trackpos = fESD->GetTrack(iTracks);
+  for (Int_t iTracks = 0; iTracks < esd->GetNumberOfTracks(); iTracks++) {
+    AliESDtrack* trackpos = esd->GetTrack(iTracks);
     if (!trackpos) {
       Printf("ERROR: Could not receive track %d", iTracks);
       continue;
@@ -258,7 +276,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
     trackpos->GetPxPyPz(ptrackpos);
     
     Float_t nSigmaToVertex = GetSigmaToVertex(trackpos);      
-    
+
     Float_t bpos[2];
     Float_t bCovpos[3];
     trackpos->GetImpactParameters(bpos,bCovpos);
@@ -294,7 +312,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
     Int_t kaonKinkFlag=0;
     if(indexKinkPos<0){
                
-        AliESDkink *poskink=fESD->GetKink(TMath::Abs(indexKinkPos)-1);
+        AliESDkink *poskink=esd->GetKink(TMath::Abs(indexKinkPos)-1);
        const TVector3 motherMfromKinkPos(poskink->GetMotherP());
        const TVector3 daughterMKinkPos(poskink->GetDaughterP());
        Float_t posQt=poskink->GetQt();
@@ -327,7 +345,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
 
     }  //End Kink Information   
     
-    if(kaonKinkFlag==1) anp4pos.SetVectM(posTrackMom,daughter1Mass);
+    if(kaonKinkFlag==1) anp4pos.SetVectM(posTrackMom,daughter1pdgMass);
     
     if(indexKinkPos==0) {
       UInt_t status=trackpos->GetStatus();
@@ -342,13 +360,13 @@ void AliResonanceKinkPID::Exec(Option_t *)
       if(extCovPos[9]>0.5) continue;
       if(extCovPos[14]>2) continue; 
    
-      p4pos.SetVectM(posTrackMom, daughter2Mass);
+      p4pos.SetVectM(posTrackMom, daughter2pdgMass);
     
     }
        
-      for (Int_t j=0; j<fESD->GetNumberOfTracks(); j++) {
+      for (Int_t j=0; j<esd->GetNumberOfTracks(); j++) {
         if(iTracks==j) continue;
-        AliESDtrack* trackneg=fESD->GetTrack(j);
+        AliESDtrack* trackneg=esd->GetTrack(j);
         if (trackneg->GetSign() > 0) continue;
        
        trackneg->GetPxPyPz(ptrackneg);
@@ -388,7 +406,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
        Int_t negKaonKinkFlag=0;
        if(indexKinkNeg<0){
                
-        AliESDkink *negkink=fESD->GetKink(TMath::Abs(indexKinkNeg)-1);
+        AliESDkink *negkink=esd->GetKink(TMath::Abs(indexKinkNeg)-1);
         const TVector3 motherMfromKinkNeg(negkink->GetMotherP());
         const TVector3 daughterMKinkNeg(negkink->GetDaughterP());
         Float_t negQt=negkink->GetQt();
@@ -421,7 +439,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
 
        }  //End Kink Information   
        
-       if(negKaonKinkFlag==1) p4neg.SetVectM(negTrackMom,daughter1Mass);
+       if(negKaonKinkFlag==1) p4neg.SetVectM(negTrackMom,daughter1pdgMass);
        
        if(indexKinkNeg==0)  {
           UInt_t statusneg=trackneg->GetStatus();
@@ -438,7 +456,7 @@ void AliResonanceKinkPID::Exec(Option_t *)
            if(extCovneg[9]>0.5) continue;
            if(extCovneg[14]>2) continue;
 
-         anp4neg.SetVectM(negTrackMom, daughter2Mass);
+         anp4neg.SetVectM(negTrackMom, daughter2pdgMass);
        
         }
        
@@ -454,8 +472,8 @@ void AliResonanceKinkPID::Exec(Option_t *)
          p4comb=p4pos;
           p4comb+=p4neg;
          fInvariantMass->Fill(p4comb.M());
-         if ((mumpdgpos==(-resonancePDG))&&(mumpdgneg==(-resonancePDG))&&(mumlabelpos==mumlabelneg)
-          &&(pdgpos==daughter2)&&(pdgneg==(-daughter1))&&(TMath::Abs(trackpos->GetLabel())>=0)&&(TMath::Abs(trackneg->GetLabel())>=0)&&(mumlabelpos>=0)&&(mumlabelneg>=0)) {
+         if ((mumpdgpos==(antiresonancePDGcode))&&(mumpdgneg==(antiresonancePDGcode))&&(mumlabelpos==mumlabelneg)
+          &&(pdgpos==fdaughter2pdg)&&(pdgneg==(-fdaughter1pdg))&&(TMath::Abs(trackpos->GetLabel())>=0)&&(TMath::Abs(trackneg->GetLabel())>=0)&&(mumlabelpos>=0)&&(mumlabelneg>=0)) {
             fOpeningAngle->Fill(openingAngle);
             fInvMassTrue->Fill(p4comb.M());
            if((TMath::Abs(p4pos.Vect().Eta())<1.1)&&(TMath::Abs(p4neg.Vect().Eta())<1.1)&&(p4comb.Vect().Eta()<1.1)) {
@@ -473,8 +491,8 @@ void AliResonanceKinkPID::Exec(Option_t *)
           anp4comb=anp4pos;
           anp4comb+=anp4neg;  
          fInvariantMass->Fill(anp4comb.M());
-         if ((mumpdgpos==resonancePDG)&&(mumpdgneg==resonancePDG)&&(mumlabelpos==mumlabelneg)
-          &&(pdgpos==daughter1)&&(pdgneg==(-daughter2))&&(TMath::Abs(trackpos->GetLabel())>=0)&&(TMath::Abs(trackneg->GetLabel())>=0)&&(mumlabelpos>=0)  &&(mumlabelneg>=0)) {
+         if ((mumpdgpos==resonancePDGcode)&&(mumpdgneg==resonancePDGcode)&&(mumlabelpos==mumlabelneg)
+          &&(pdgpos==fdaughter1pdg)&&(pdgneg==(-fdaughter2pdg))&&(TMath::Abs(trackpos->GetLabel())>=0)&&(TMath::Abs(trackneg->GetLabel())>=0)&&(mumlabelpos>=0)  &&(mumlabelneg>=0)) {
             fOpeningAngle->Fill(openingAngle);
             fInvMassTrue->Fill(p4comb.M());
             if((TMath::Abs(anp4neg.Vect().Eta())<1.1)&&(TMath::Abs(anp4pos.Vect().Eta())<1.1)&&(anp4comb.Vect().Eta()<1.1)) {  
@@ -493,29 +511,10 @@ void AliResonanceKinkPID::Exec(Option_t *)
   
   } // end fAnalysisType == ESD
   
-    PostData(1, fListOfHistos);
 }      
 
-//________________________________________________________________________
-void AliResonanceKinkPID::Terminate(Option_t *) 
-{
-  // Draw result to the screen 
-  // Called once at the end of the query
-
-//  fHistPt = dynamic_cast<TH1F*> (GetOutputData(0));
-//  if (!fHistPt) {
-//    Printf("ERROR: fHistPt not available");
-//    return;
-//  }
-   
-//  TCanvas *c1 = new TCanvas("AliResonanceKinkPID","Pt MC",10,10,510,510);
-//  c1->cd(1)->SetLogy();
-//  fHistPt->DrawCopy("E");
-}
-
 //____________________________________________________________________//
-
-Float_t AliResonanceKinkPID::GetSigmaToVertex(AliESDtrack* esdTrack) const {
+Float_t AliResonanceKink::GetSigmaToVertex(AliESDtrack* esdTrack) const {
   // Calculates the number of sigma to the vertex.
   
   Float_t b[2];
@@ -525,9 +524,9 @@ Float_t AliResonanceKinkPID::GetSigmaToVertex(AliESDtrack* esdTrack) const {
     esdTrack->GetImpactParameters(b,bCov);
   
   if (bCov[0]<=0 || bCov[2]<=0) {
-    //AliDebug(1, "Estimated b resolution lower or equal zero!");
     bCov[0]=0; bCov[2]=0;
   }
+  
   bRes[0] = TMath::Sqrt(bCov[0]);
   bRes[1] = TMath::Sqrt(bCov[2]);
   
@@ -542,9 +541,8 @@ Float_t AliResonanceKinkPID::GetSigmaToVertex(AliESDtrack* esdTrack) const {
   return d;
 }
 
-//____________________________________________________________________//
-
-const AliESDVertex* AliResonanceKinkPID::GetEventVertex(const AliESDEvent* esd) const
+//________________________________________________________________________
+const AliESDVertex* AliResonanceKink::GetEventVertex(const AliESDEvent* esd) const
 {
   // Get the vertex 
   
@@ -560,3 +558,5 @@ const AliESDVertex* AliResonanceKinkPID::GetEventVertex(const AliESDEvent* esd)
   }
 }
 
+
+ 

diff --git a/PWG2/KINK/AliResonanceKinkPID.h b/PWG2/KINK/AliResonanceKink.h
similarity index 55%
rename from PWG2/KINK/AliResonanceKinkPID.h
rename to PWG2/KINK/AliResonanceKink.h
index 4dae3f7bcd0e1466e7c21e868804b1a6f7b8e84a..64b4eea1228fd011a2adf8e4b4b725081fe7065f 100644 (file)
--- a/PWG2/KINK/AliResonanceKinkPID.h
+++ b/PWG2/KINK/AliResonanceKink.h
@@ -1,37 +1,43 @@
-#ifndef ALIRESONANCEKINKPID_H
-#define ALIRESONANCEKINKPID_H
+#ifndef ALIRESONANCEKINK_H
+#define ALIRESONANCEKINK_H
 
 /*  See cxx source for full Copyright notice */
 
 //------------------------------------------------------------------------------
-//                   class AliResonanceKinkPID
+//                   class AliResonanceKink
 //         This task is an example of an analysis task
 //        for analysing resonances having one kaon kink
 //Author: Paraskevi Ganoti, University of Athens (pganoti@phys.uoa.gr)
 //------------------------------------------------------------------------------
 
 class TF1;
-class TString;
-class TTree;
 class AliESDEvent;
 class AliESDtrack;
+class AliESDVertex;
+class AliMCEvent;
+class TList;
+class TString;
 
-class AliResonanceKinkPID : public AliAnalysisTaskSE {
+class AliResonanceKink : public TObject {
  public:
-  AliResonanceKinkPID();
-  AliResonanceKinkPID(const char *name);
-  virtual ~AliResonanceKinkPID() {}
+ 
+  enum ResonanceType {kPhi=333, kKstar0=313, kLambda1520=3124};
+  enum DaughterType {kdaughterPion=211, kdaughterKaon=321, kdaughterProton=2212};
   
-  virtual void   ConnectInputData(Option_t *);
-  virtual void   CreateOutputObjects();
-  virtual void   Exec(Option_t *option);
-  virtual void   Terminate(Option_t *);
+  AliResonanceKink();
+  AliResonanceKink(Int_t nbins, Float_t nlowx, Float_t nhighx, Int_t daughter1, Int_t daughter2, Int_t resonancePDG);
+  virtual ~AliResonanceKink();
   
+  TList* GetHistogramList();
+  void Analyse(AliESDEvent* esd, AliMCEvent* mcEvent);  
   Float_t GetSigmaToVertex(AliESDtrack* esdTrack) const ; 
   const AliESDVertex *GetEventVertex(const AliESDEvent* esd) const;
-  
+  void SetAnalysisType(TString type) {fAnalysisType=type;}
+  void SetPDGCodes(Int_t d1, Int_t d2, Int_t res) {fdaughter1pdg=d1; fdaughter2pdg=d2; fresonancePDGcode=res;}
+  void InitOutputHistograms(Int_t nbins, Float_t nlowx, Float_t nhighx);
+ 
  private:
-  AliESDEvent *fESD;    //! ESD object
+ 
   TList       *fListOfHistos; //! List 
   TH1D        *fOpeningAngle; //! Opening  
   TH1D        *fInvariantMass; //! invMass spectrum   
@@ -52,11 +58,17 @@ class AliResonanceKinkPID : public AliAnalysisTaskSE {
   TF1         *f2;  
   TString     fAnalysisType;//"ESD" or "MC"
   TH1D        *fvtxz ; //! vtx z component
+  Int_t       fNbins; //! bins
+  Float_t     fLowX;//! lowx
+  Float_t     fHighX; //! high x
+  Int_t       fdaughter1pdg;
+  Int_t       fdaughter2pdg;  
+  Int_t       fresonancePDGcode;
   
-  AliResonanceKinkPID(const AliResonanceKinkPID&); // not implemented
-  AliResonanceKinkPID& operator=(const AliResonanceKinkPID&); // not implemented
+  AliResonanceKink(const AliResonanceKink&); // not implemented
+  AliResonanceKink& operator=(const AliResonanceKink&); // not implemented
 
-  ClassDef(AliResonanceKinkPID, 1); // example of analysis
+  ClassDef(AliResonanceKink, 1); // example of analysis
 };
 
 #endif

diff --git a/PWG2/KINK/macros/AddTaskKinkResonance.C b/PWG2/KINK/macros/AddTaskKinkResonance.C
index e36b7bf652eb499c86a5e660ac243c2aca5b6e8c..0eb63877f70016a0b5d887018631ea2ba20f9ce8 100644 (file)
--- a/PWG2/KINK/macros/AddTaskKinkResonance.C
+++ b/PWG2/KINK/macros/AddTaskKinkResonance.C
@@ -1,47 +1,55 @@
-AliResonanceKinkPID *AddTaskKinkResonance(Short_t lCollidingSystems=0  /*0 = pp, 1 = AA*/)
+AliAnalysisTaskKinkResonance *AddTaskKinkResonanceKstar(Short_t lCollidingSystems=0 /*0 = pp, 1 = AA*/)
 {
-// Creates, configures and attaches to the train a V0 check task.
-   // Get the pointer to the existing analysis manager via the static access method.
-   //==============================================================================
-   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-   if (!mgr) {
-      ::Error("AddTaskKinkResonance", "No analysis manager to connect to.");
-      return NULL;
-   }   
+// Creates, configures and attaches to the train a kink resonance task.
+// Get the pointer to the existing analysis manager via the static access method.
+//==============================================================================
+AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskKinkResonanceKstar", "No analysis manager to connect to.");
+return NULL;
+}
 
-   // Check the analysis type using the event handlers connected to the analysis manager.
-   //==============================================================================
-   if (!mgr->GetInputEventHandler()) {
-      ::Error("AddTaskKinkResonance", "This task requires an input event handler");
-      return NULL;
-   }   
-   TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
-   if (type != "ESD") {
-      ::Error("AddTaskKinkResonance", "This task needs an ESD input handler");
-      return NULL;
-   }   
-   if (!mgr->GetMCtruthEventHandler()) {
-      ::Error("AddTaskKinkResonance", "This task needs an MC handler");
-      return NULL;
-   }
+// Check the analysis type using the event handlers connected to the analysis manager.
+//==============================================================================
+if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTaskKinkResonanceKstar", "This task requires an input event handler");
+ return NULL;
+}
+TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
+ if (type != "ESD") {
+ ::Error("AddTaskKinkResonanceKstar", "This task needs an ESD input handler");
+return NULL;
+}
+if (!mgr->GetMCtruthEventHandler()) {
+ ::Error("AddTaskKinkResonanceKstar", "This task needs an MC handler");
+ return NULL;
+}
 
-   // Create and configure the task
-       AliResonanceKinkPID *taskkinkresonance = new AliResonanceKinkPID("TaskResKinkPID");
-   mgr->AddTask(taskkinkresonance);
+// Setup the analysis object
+  
+  AliResonanceKink  *kinkResonanceObject=new AliResonanceKink();
+  kinkResonanceObject->InitOutputHistograms(60, 0.6, 1.2);
+  kinkResonanceObject->SetPDGCodes(kKPlus, kPiPlus, AliResonanceKink::kKstar0); 
+  kinkResonanceObject->SetAnalysisType("ESD"); // "ESD" or "MC"
 
-   // Create ONLY the output containers for the data produced by the task.
-   // Get and connect other common input/output containers via the manager as below
-   //==============================================================================
-   TString outname = "PP";
-   if (lCollidingSystems) outname = "AA";
-   if (mgr->GetMCtruthEventHandler()) outname += "-MC-";
-   outname += "KinkResonanceList.root";
-       AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("KinkResPID",
-                                                                  TList::Class(),
-                                                                  AliAnalysisManager::kOutputContainer,
-                                                                  outname );
-                           
-       mgr->ConnectInput(taskkinkresonance, 0, mgr->GetCommonInputContainer());
-   mgr->ConnectOutput(taskkinkresonance, 1, coutput1);
-   return taskkinkresonance;
-}   
+// Create and configure the task
+AliAnalysisTaskKinkResonance *taskresonanceKstar = new AliAnalysisTaskKinkResonance("TaskResKinkPID");
+taskresonanceKstar->SetAnalysisKinkObject(kinkResonanceObject);
+mgr->AddTask(taskresonanceKstar);
+
+// Create ONLY the output containers for the data produced by the task.
+// Get and connect other common input/output containers via the manager as below
+//==============================================================================
+TString outname = "PP";
+if (lCollidingSystems) outname = "AA";
+if (mgr->GetMCtruthEventHandler()) outname += "-MC-";
+outname += "KinkResonanceList.root";
+AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("KinkResKstar",
+                                                          TList::Class(),
+                                                          AliAnalysisManager::kOutputContainer,
+                                                          outname );
+
+mgr->ConnectInput(taskresonanceKstar, 0, mgr->GetCommonInputContainer());
+mgr->ConnectOutput(taskresonanceKstar, 1, coutput1);
+return taskresonanceKstar;
+} 

diff --git a/PWG2/PWG2kinkLinkDef.h b/PWG2/PWG2kinkLinkDef.h
index c6a02dad9d7b218d91f1d75e9fc1720769f23198..34b6be19612290a13e5130aca087b91fceb5d449 100644 (file)
--- a/PWG2/PWG2kinkLinkDef.h
+++ b/PWG2/PWG2kinkLinkDef.h
@@ -6,6 +6,7 @@
 
 #pragma link C++ class AliAnalysisKinkESDMC+;
 #pragma link C++ class AliResonanceKinkLikeSign+;
-#pragma link C++ class AliResonanceKinkPID+;
+#pragma link C++ class AliResonanceKink+;
+#pragma link C++ class AliAnalysisTaskKinkResonance+;
 
 #endif

diff --git a/PWG2/libPWG2kink.pkg b/PWG2/libPWG2kink.pkg
index 2233730000f6937456e1a32c9a22787db8dd7604..6be6124249314424809cb43471afe3ffd3acf40a 100644 (file)
--- a/PWG2/libPWG2kink.pkg
+++ b/PWG2/libPWG2kink.pkg
@@ -2,7 +2,8 @@
 
 SRCS= KINK/AliAnalysisKinkESDMC.cxx \
       KINK/AliResonanceKinkLikeSign.cxx \
-      KINK/AliResonanceKinkPID.cxx
+      KINK/AliResonanceKink.cxx \
+      KINK/AliAnalysisTaskKinkResonance.cxx
 
 HDRS= $(SRCS:.cxx=.h)