Added a new cut, an example macro for efficiency computation and a structure for...
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 23 Sep 2010 08:58:19 +0000 (08:58 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 23 Sep 2010 08:58:19 +0000 (08:58 +0000)
19 files changed:
PWG2/PWG2resonancesLinkDef.h
PWG2/RESONANCES/AliRsnAnalysisMonitorTask.cxx
PWG2/RESONANCES/AliRsnAnalysisMonitorTask.h
PWG2/RESONANCES/AliRsnCut.h
PWG2/RESONANCES/AliRsnCutValue.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutValue.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnValue.cxx
PWG2/RESONANCES/AliRsnValue.h
PWG2/RESONANCES/doc/ConfigTaskRsnTest.C [new symlink]
PWG2/RESONANCES/doc/rsndoc.aux [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.log [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.nav [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.out [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.pdf [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.snm [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.tex [new file with mode: 0644]
PWG2/RESONANCES/doc/rsndoc.toc [new file with mode: 0644]
PWG2/RESONANCES/macros/test/AddAnalysisTaskRsnEff.C [new file with mode: 0644]
PWG2/libPWG2resonances.pkg

index d1184df..f9217a7 100644 (file)
@@ -4,6 +4,9 @@
 #pragma link C++ class AliRsnMother+;
 #pragma link C++ class AliRsnEvent+;
 
+#pragma link C++ class AliRsnValue+;
+#pragma link C++ class AliRsnFunction+;
+
 #pragma link C++ class AliRsnExpression+;
 #pragma link C++ class AliRsnVariableExpression+;
 #pragma link C++ class AliRsnCut+;
 #pragma link C++ class AliRsnCutPrimaryVertex+;
 #pragma link C++ class AliRsnCutDaughterType+;
 #pragma link C++ class AliRsnCutESD2010+;
+#pragma link C++ class AliRsnCutValue+;
 
 #pragma link C++ class AliRsnCutSet+;
 #pragma link C++ class AliRsnCutManager+;
 
-#pragma link C++ class AliRsnValue+;
-#pragma link C++ class AliRsnFunction+;
-
 #pragma link C++ class AliRsnPairDef+;
 #pragma link C++ class AliRsnPair+;
 #pragma link C++ class AliRsnPairFunctions+;
index 0dd224b..6ae21fe 100644 (file)
 #include "AliCDBManager.h"
 #include "AliITSPIDResponse.h"
 #include "AliRsnMonitorTrack.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnEvent.h"
 
 #include "AliRsnAnalysisMonitorTask.h"
 
 //__________________________________________________________________________________________________
 AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const char *name) :
   AliAnalysisTaskSE(name),
+  fEventOK(kFALSE),
   fEventType(2),
   fNTracks(0),
   fOut(0x0),
   fTracks(0x0),
-  fMaxITSband(1E6),
-  fTPCpLimit(0.35),
-  fLargeTPCband(-1E6),
-  fSmallTPCband( 1E6),
-  fESDtrackCutsTPC(),
-  fESDtrackCutsITS(),
   fESDpid(0x0),
   fTOFmaker(0x0),
   fTOFcalib(0x0),
@@ -48,7 +45,9 @@ AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const char *name) :
   fTOFcorrectTExp(kFALSE),
   fTOFuseT0(kFALSE),
   fTOFtuneMC(kFALSE),
-  fTOFresolution(0.0)
+  fTOFresolution(0.0),
+  fEventCuts("eventCuts", AliRsnCut::kEvent),
+  fTrackCuts("trackCuts", AliRsnCut::kDaughter)
   
 {
 //
@@ -61,16 +60,11 @@ AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const char *name) :
 //__________________________________________________________________________________________________
 AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitorTask& copy) :
   AliAnalysisTaskSE(copy),
+  fEventOK(kFALSE),
   fEventType(2),
   fNTracks(0),
   fOut(0x0),
   fTracks(0x0),
-  fMaxITSband(copy.fMaxITSband),
-  fTPCpLimit(copy.fTPCpLimit),
-  fLargeTPCband(copy.fLargeTPCband),
-  fSmallTPCband(copy.fSmallTPCband),
-  fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
-  fESDtrackCutsITS(copy.fESDtrackCutsITS),
   fESDpid(0x0),
   fTOFmaker(0x0),
   fTOFcalib(0x0),
@@ -78,7 +72,9 @@ AliRsnAnalysisMonitorTask::AliRsnAnalysisMonitorTask(const AliRsnAnalysisMonitor
   fTOFcorrectTExp(kFALSE),
   fTOFuseT0(kFALSE),
   fTOFtuneMC(kFALSE),
-  fTOFresolution(0.0)
+  fTOFresolution(0.0),
+  fEventCuts(copy.fEventCuts),
+  fTrackCuts(copy.fTrackCuts)
 {
 //
 // Copy constructor
@@ -92,15 +88,6 @@ AliRsnAnalysisMonitorTask& AliRsnAnalysisMonitorTask::operator=(const AliRsnAnal
 // Assignment operator
 //
 
-  fMaxITSband = copy.fMaxITSband;
-  
-  fTPCpLimit    = copy.fTPCpLimit;
-  fLargeTPCband = copy.fSmallTPCband;
-  fSmallTPCband = copy.fLargeTPCband;
-  
-  fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
-  fESDtrackCutsITS = copy.fESDtrackCutsITS;
-  
   fTOFcalibrateESD = copy.fTOFcalibrateESD;
   fTOFcorrectTExp = copy.fTOFcorrectTExp;
   fTOFuseT0 = copy.fTOFuseT0;
@@ -147,7 +134,8 @@ void AliRsnAnalysisMonitorTask::UserCreateOutputObjects()
   // link branches
   fOut->Branch("ntracks", &fNTracks     , "ntracks/I"   );
   fOut->Branch("evtype" , &fEventType   , "evtype/I"    );
-  fOut->Branch("vertex" , &fVertex      , "vertex[3]/F");
+  fOut->Branch("evok"   , &fEventOK     , "evok/O"      );
+  fOut->Branch("vertex" , &fVertex      , "vertex[3]/F" );
   fOut->Branch("tracks" , "TClonesArray", &fTracks      );
 }
 
@@ -248,6 +236,14 @@ void AliRsnAnalysisMonitorTask::ProcessESD
 // TClonesArray which is one of the branches of the output TTree.
 //
 
+  // create interfacr objects
+  AliRsnEvent    event;
+  AliRsnDaughter daughter;
+  event.SetRef(esd, fMCEvent);
+  
+  // check event cuts and track cuts
+  fEventOK = fEventCuts.IsSelected(&event);
+
   // clear array
   fTracks->Delete();
   fTracks->Clear();
@@ -278,34 +274,32 @@ void AliRsnAnalysisMonitorTask::ProcessESD
     fTOFmaker->ApplyT0TOF(esd);
     fESDpid->MakePID(esd, kFALSE, 0.);
   }
-  // TOF stuff #4: define fixed functions for compatibility range
-  Double_t a1 = 0.01, a2 = -0.03;
-  Double_t b1 = 0.25, b2 =  0.25;
-  Double_t c1 = 0.05, c2 = -0.03;
-  Double_t ymax, ymin;
   
   // loop on all tracks
-  Int_t               i, k, size, nITS;
-  Double_t            tpcMaxNSigma, itsdedx[4], tofRef, tofRel;
-  Bool_t              okTOF, okTrack, isTPC, isITSSA, matchedTOF;
-  UChar_t             itsCluMap;
+  Int_t               i, k, size;
+  Double_t            itsdedx[4];
+  Bool_t              isTPC, isITSSA;
   Float_t             b[2], bCov[3];
   AliRsnMonitorTrack  mon;
   
   for (i = 0; i < fNTracks; i++)
   {
     AliESDtrack *track = esd->GetTrack(i);
+    event.SetDaughter(daughter, i, AliRsnDaughter::kTrack);
     
+    // reset the output object
+    // 'usable' flag will need to be set to 'ok'
+    mon.Reset();
+    
+    // check cuts
+    mon.CutsPassed() = fTrackCuts.IsSelected(&daughter);
+        
     // skip NULL pointers, kink daughters and tracks which
     // cannot be propagated to primary vertex
     if (!track) continue;
     if ((Int_t)track->GetKinkIndex(0) > 0) continue;
     if (!track->RelateToVertex(v, esd->GetMagneticField(), kVeryBig)) continue;
     
-    // reset the output object
-    // 'usable' flag will need to be set to 'ok'
-    mon.Reset();
-    
     // get MC info if possible
     if (stack) mon.AdoptMC(TMath::Abs(track->GetLabel()), stack);
     
@@ -320,7 +314,6 @@ void AliRsnAnalysisMonitorTask::ProcessESD
     // evaluate some flags from the status to decide what to do next in some points
     isTPC      = ((mon.Status() & AliESDtrack::kTPCin)  != 0);
     isITSSA    = ((mon.Status() & AliESDtrack::kTPCin)  == 0 && (mon.Status() & AliESDtrack::kITSrefit) != 0 && (mon.Status() & AliESDtrack::kITSpureSA) == 0 && (mon.Status() & AliESDtrack::kITSpid) != 0);
-    matchedTOF = ((mon.Status() & AliESDtrack::kTOFout) != 0 && (mon.Status() & AliESDtrack::kTIME) != 0);
     
     // accept only tracks which are TPC+ITS or ITS standalone
     if (!isTPC && !isITSSA) continue;
@@ -373,51 +366,6 @@ void AliRsnAnalysisMonitorTask::ProcessESD
     // if we are here, the track is usable
     mon.SetUsable();
     
-    // now check the track against its cuts
-    // and update the flag related to it
-    // first, assume that cuts were passed
-    // and if they aren't, just update the flag accordingly
-    mon.CutsPassed() = kTRUE;
-    if (TMath::Abs(mon.DCAz()) > 3.0) mon.CutsPassed() = kFALSE;
-    
-    if (isTPC)
-    {
-      // check standard ESD cuts
-      if (!fESDtrackCutsTPC.IsSelected(track)) mon.CutsPassed() = kFALSE;
-      
-      // check TPC dE/dx
-      if (mon.Ptpc() > fTPCpLimit) tpcMaxNSigma = fSmallTPCband; else tpcMaxNSigma = fLargeTPCband;
-      if (TMath::Abs(mon.TPCnsigma()) > tpcMaxNSigma) mon.CutsPassed() = kFALSE;
-      
-      // check TOF (only if momentum is large than function asymptote and flags are OK)
-      okTOF = kTRUE;
-      if (matchedTOF && mon.Prec() > TMath::Max(b1, b2))
-      {
-        tofRef = mon.TOFref(AliPID::kKaon);
-        if (tofRef > 0.0)
-        {
-          tofRel   = (mon.TOFsignal() - tofRef) / tofRef;
-          ymax     = a1 / (mon.Prec() - b1) + c1;
-          ymin     = a2 / (mon.Prec() - b2) + c2;
-          okTOF    = (tofRel >= ymin && tofRel <= ymax);
-        }
-      }
-      if (!okTOF) mon.CutsPassed() = kFALSE;
-    }
-    else
-    {
-      // check standard ESD cuts
-      if (!fESDtrackCutsITS.IsSelected(track)) mon.CutsPassed() = kFALSE;
-      
-      // check dE/dx
-      itsCluMap = track->GetITSClusterMap();
-      nITS      = 0;
-      for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
-      if (nITS < 3) okTrack = kFALSE; // track not good for PID
-      mon.ITSnsigma() = itsrsp.GetNumberOfSigmas(mon.Prec(), mon.ITSsignal(), AliPID::kKaon, nITS, kTRUE);
-      if (TMath::Abs(mon.ITSnsigma()) > fMaxITSband) mon.CutsPassed() = kFALSE;
-    }
-    
     // collect only tracks which are declared usable
     if (mon.IsUsable())
     {
index 6215c70..1e1b9a7 100644 (file)
@@ -8,7 +8,7 @@
 #define ALIRSNANALYSISMONITORTASK_H
 
 #include "AliAnalysisTaskSE.h"
-#include "AliESDtrackCuts.h"
+#include "AliRsnCutSet.h"
 
 class TH1I;
 class TH1F;
@@ -30,10 +30,6 @@ class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE
     AliRsnAnalysisMonitorTask& operator=(const AliRsnAnalysisMonitorTask& copy);
     virtual ~AliRsnAnalysisMonitorTask();
     
-    void             SetITSband(Double_t v) {fMaxITSband = v;}
-    
-    void             SetTPClargeBandLimit(Double_t v)        {fTPCpLimit = v;}
-    void             SetTPCbands(Double_t min, Double_t max) {fLargeTPCband = min; fSmallTPCband = max;}
     void             SetTPCpar(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4)
                        {fTPCpar[0]=p0;fTPCpar[1]=p1;fTPCpar[2]=p2;fTPCpar[3]=p3;fTPCpar[4]=p4;}
 
@@ -50,12 +46,14 @@ class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE
     void             EventEval(AliESDEvent *esd);
     Bool_t           IsTPCtrack(AliESDtrack *track);
     Bool_t           IsITSSAtrack(AliESDtrack *track);
-    AliESDtrackCuts& GetCutsTPC() {return fESDtrackCutsTPC;}
-    AliESDtrackCuts& GetCutsITS() {return fESDtrackCutsITS;}
     void             ProcessESD(AliESDEvent *esd, const AliESDVertex *v, AliStack *stack);
+    
+    AliRsnCutSet*    GetEventCuts() {return &fEventCuts;}
+    AliRsnCutSet*    GetTrackCuts() {return &fTrackCuts;}
 
   private:
     
+    Bool_t           fEventOK;             // tells if event cuts were passed
     Int_t            fEventType;           // event classification (0 = vertex with tracks, 1 = vertex with SPD, 2 = bad vertex)
     Double_t         fVertex[3];           // primary vertex position
     Int_t            fNTracks;             // counter for tracks
@@ -63,14 +61,8 @@ class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE
     TTree           *fOut;                 // output TTree
     TClonesArray    *fTracks;              // array of data from tracks
     
-    Double_t         fMaxITSband;          // range for ITS de/dx band
-    Double_t         fTPCpLimit;           // limit to choose what band to apply
     Double_t         fTPCpar[5];           // parameters for TPC bethe-Bloch
-    Double_t         fLargeTPCband;        // range for TPC de/dx band - min
-    Double_t         fSmallTPCband;        // range for TPC de/dx band - max
    
-    AliESDtrackCuts  fESDtrackCutsTPC;     //  ESD standard defined track cuts for TPC tracks
-    AliESDtrackCuts  fESDtrackCutsITS;     //  ESD standard defined track cuts for ITS-SA tracks
     AliESDpid       *fESDpid;              //! PID manager
     
     AliTOFT0maker   *fTOFmaker;            //! TOF time0 computator
@@ -80,6 +72,9 @@ class AliRsnAnalysisMonitorTask : public AliAnalysisTaskSE
     Bool_t           fTOFuseT0;            //  TOF settings
     Bool_t           fTOFtuneMC;           //  TOF settings
     Double_t         fTOFresolution;       //  TOF settings
+    
+    AliRsnCutSet     fEventCuts;           // event cuts
+    AliRsnCutSet     fTrackCuts;           // track cuts
 
     // ROOT dictionary
     ClassDef(AliRsnAnalysisMonitorTask,1)
index ddf4bd3..6438a55 100644 (file)
@@ -50,44 +50,56 @@ class AliRsnCut : public TNamed
     AliRsnCut(const char *name, ETarget target, Int_t    min, Int_t    max = 0 );
     AliRsnCut(const char *name, ETarget target, Double_t min, Double_t max = 0.);
     virtual ~AliRsnCut() { /*nothing*/ };
-
+    
+    EVarType         GetVarTypeEnum() {return fVarType;}
+    Char_t           GetVarTypeChar() {if (fVarType == kInt) return 'I'; else if (fVarType == kDouble) return 'D'; else return 'X';}
+    ETarget          GetTargetEnum()  {return fTarget;}
+    Char_t           GetTargetChar()  {if (fTarget == kDaughter) return 'D'; else if (fTarget == kMother) return 'M'; else if (fTarget == kEvent) return 'E'; else return 'X';}
+    Bool_t           IsTarget(ETarget target) {return (fTarget == target);}
+    Bool_t           TargetOK(TObject *obj1, TObject *obj2 = 0x0);
+    Int_t            GetMinI()        {return fMinI;}
+    Int_t            GetMaxI()        {return fMaxI;}
+    Double_t         GetMinD()        {return fMinD;}
+    Double_t         GetMaxD()        {return fMaxD;}
+    Int_t            GetCutValueI()   {return fCutValueI;}
+    Double_t         GetCutValueD()   {return fCutValueD;}
+    Bool_t           GetCutResult()   {return fCutResult;}
+    
     void             SetRange(Int_t    min, Int_t    max) {fMinI = min; fMaxI = max; fVarType = kInt;}
     void             SetRange(Double_t min, Double_t max) {fMinD = min; fMaxD = max; fVarType = kDouble;}
 
     void             SetValue(Int_t value)    {fMinI = value; fVarType = kInt;}
     void             SetValue(Double_t value) {fMinD = value; fVarType = kDouble;}
+    
+    Bool_t           OkValue();
+    Bool_t           OkRange();
+    Bool_t           OkValueI();
+    Bool_t           OkRangeI();
+    Bool_t           OkValueD();
+    Bool_t           OkRangeD();
 
     virtual void     SetEvent(AliRsnEvent *event);
+    AliRsnEvent*     GetEvent() {return fEvent;}
     
-    ETarget          GetTarget() {return fTarget;}
-    Bool_t           IsTarget(ETarget target) {return (fTarget == target);}
-    Bool_t           TargetOK  (TObject *obj1, TObject *obj2 = 0x0);
     virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
     virtual void     Print(Option_t *opt = "") const;
 
   protected:
 
-    Bool_t  OkValue();
-    Bool_t  OkRange();
-    Bool_t  OkValueI();
-    Bool_t  OkRangeI();
-    Bool_t  OkValueD();
-    Bool_t  OkRangeD();
-
-    EVarType  fVarType;    // type of checked variable
-    ETarget   fTarget;     // type of object on which the cut is checked
+    EVarType     fVarType;    // type of checked variable
+    ETarget      fTarget;     // type of object on which the cut is checked
 
-    Int_t     fMinI;       // lower edge of INT range or ref. value for INT CUT
-    Int_t     fMaxI;       // upper edge of INT range (not used for value cuts)
-    Double_t  fMinD;       // lower edge of DOUBLE range or ref. value for INT CUT
-    Double_t  fMaxD;       // upper edge of DOUBLE range (not used for value cuts)
+    Int_t        fMinI;       // lower edge of INT range or ref. value    for INT CUT
+    Int_t        fMaxI;       // upper edge of INT range (not used    for value cuts)
+    Double_t     fMinD;       // lower edge of DOUBLE range or ref. value    for INT CUT
+    Double_t     fMaxD;       // upper edge of DOUBLE range (not used    for value cuts)
 
-    Int_t     fCutValueI;  // cut value INT
-    Double_t  fCutValueD;  // cut value DOUBLE
+    Int_t        fCutValueI;  // cut value INT
+    Double_t     fCutValueD;  // cut value DOUBLE
     
-    Bool_t    fCutResult;  // tells if the cut is passed or not
+    Bool_t       fCutResult;  // tells if the cut is passed or not
 
-    AliRsnEvent *fEvent;   //! pointer to current event (can be needed sometimes)
+    AliRsnEvent *fEvent;      //! pointer to current event (can be needed sometimes, but never streamed)
 
     ClassDef(AliRsnCut, 1)
 };
diff --git a/PWG2/RESONANCES/AliRsnCutValue.cxx b/PWG2/RESONANCES/AliRsnCutValue.cxx
new file mode 100644 (file)
index 0000000..9e79559
--- /dev/null
@@ -0,0 +1,106 @@
+//
+// Class AliRsnCutValue
+//
+// General implementation of a single cut strategy, which can be:
+// - a value contained in a given interval  [--> IsBetween()   ]
+// - a value equal to a given reference     [--> MatchesValue()]
+//
+// In all cases, the reference value(s) is (are) given as data members
+// and each kind of cut requires a given value type (Int, UInt, Double),
+// but the cut check procedure is then automatized and chosen thanks to
+// an enumeration of the implemented cut types.
+// At the end, the user (or any other point which uses this object) has
+// to use the method IsSelected() to check if this cut has been passed.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include <TMath.h>
+#include <TLorentzVector.h>
+
+#include "AliStack.h"
+#include "AliMCEvent.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnMother.h"
+#include "AliRsnEvent.h"
+#include "AliRsnValue.h"
+
+#include "AliRsnCutValue.h"
+
+ClassImp(AliRsnCutValue)
+
+//_________________________________________________________________________________________________
+AliRsnCutValue::AliRsnCutValue() :
+  AliRsnCut(),
+  fValue(),
+  fPairDef(0x0)
+{
+//
+// Default constructor.
+//
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutValue::AliRsnCutValue
+(const char *name, ETarget target, Double_t min, Double_t max, AliRsnPairDef *pd) :
+  AliRsnCut(name, target, min, max),
+  fValue(Form("val_%s", name), AliRsnValue::kValueTypes),
+  fPairDef(pd)
+{
+//
+// Main constructor.
+//
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutValue::AliRsnCutValue(const AliRsnCutValue& copy) :
+  AliRsnCut(copy),
+  fValue(copy.fValue),
+  fPairDef(copy.fPairDef)
+{
+//
+// Copy constructor
+//
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutValue& AliRsnCutValue::operator=(const AliRsnCutValue& copy)
+{
+//
+// Assignment operator
+//
+
+  (*this)  = copy;
+  fValue   = copy.fValue;
+  fPairDef = copy.fPairDef;
+  
+  return (*this);
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCutValue::IsSelected(TObject *obj1, TObject * /*obj2*/)
+{
+//
+// Checks the cut.
+// Calls the appropriate AliRsnValue::Eval() method
+// depending on the type of passed object.
+// It is up to the user to be sure that the association is meaningful
+//
+
+  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
+  AliRsnMother   *mother   = dynamic_cast<AliRsnMother*>(obj1);
+  
+  if (daughter)
+  {
+    if (!fValue.Eval(daughter, fEvent)) return kFALSE;
+    fCutValueD = fValue.GetValue();
+  }
+  else if (mother)
+  {
+    if (!fValue.Eval(mother, fPairDef, fEvent)) return kFALSE;
+    fCutValueD = fValue.GetValue();
+  }
+  
+  return OkRangeD();
+}
diff --git a/PWG2/RESONANCES/AliRsnCutValue.h b/PWG2/RESONANCES/AliRsnCutValue.h
new file mode 100644 (file)
index 0000000..53520eb
--- /dev/null
@@ -0,0 +1,44 @@
+//
+// Class AliRsnCutRange
+//
+// General implementation of cuts which check a value inside a range.
+// This range can be defined by two integers or two doubles.
+// A user-friendly enumeration allows to define what is checked.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNCUTVALUE_H
+#define ALIRSNCUTVALUE_H
+
+#include "AliRsnCut.h"
+
+class AliRsnDaughter;
+class AliRsnMother;
+class AliRsnEvent;
+
+class AliRsnCutValue : public AliRsnCut
+{
+  public:
+
+    AliRsnCutValue();
+    AliRsnCutValue(const char *name, ETarget target, Double_t min, Double_t max, AliRsnPairDef *pd = 0x0);
+    AliRsnCutValue(const AliRsnCutValue& copy);
+    AliRsnCutValue& operator=(const AliRsnCutValue& copy);
+    virtual ~AliRsnCutValue() { }
+
+    void           SetPairDef(AliRsnPairDef *pd) {fPairDef = pd;}
+    AliRsnValue*   GetRsnValue() {return &fValue;}
+    Double_t       GetCutValue() {return fValue.GetValue();}
+    virtual Bool_t IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+
+  protected:
+  
+    AliRsnValue    fValue;
+    AliRsnPairDef *fPairDef;
+
+    ClassDef(AliRsnCutValue, 1)
+};
+
+#endif
index 82d5380..df94931 100644 (file)
@@ -257,6 +257,30 @@ Bool_t AliRsnValue::Eval(AliRsnMother * const mother, AliRsnPairDef * const pair
 }
 
 //_____________________________________________________________________________
+Bool_t AliRsnValue::Eval(AliRsnDaughter * const daughter, AliRsnEvent * const event)
+{
+//
+// Evaluation of the required value.
+// Checks that the passed object is of the right type
+// and if this check is successful, returns the required value.
+// The output of the function tells if it was successful,
+// and the values must be taken with GetValue().
+//
+
+  // avoid segfaults
+  if (!daughter) return kFALSE;
+
+  switch (fType)
+  {
+    default:
+      AliWarning("Invalid value type");
+      return kFALSE;
+  }
+  
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
 void AliRsnValue::Print(Option_t *) const
 {
 //
index 13d0c30..6c74d36 100644 (file)
@@ -66,8 +66,12 @@ class AliRsnValue : public TNamed
     void        SetBins(Int_t n, Double_t min, Double_t max);
     void        SetBins(Double_t min, Double_t max, Double_t step);
     void        SetBins(Int_t n, Double_t *array);
+    void        Set(EValueType type, Int_t n = 0, Double_t min = 0.0, Double_t max = 0.0) {fType = type; SetBins(n, min, max);}
+    void        Set(EValueType type, Double_t min, Double_t max, Double_t step) {fType = type; SetBins(min, max, step);}
+    void        Set(EValueType type, Int_t n, Double_t *array) {fType = type; SetBins(n, array);}
     
     Bool_t      Eval(AliRsnMother * const mother, AliRsnPairDef * const pairDef, AliRsnEvent * const event);
+    Bool_t      Eval(AliRsnDaughter * const daughter, AliRsnEvent * const event);
     void        Print(Option_t *option = "") const;
 
   protected:
diff --git a/PWG2/RESONANCES/doc/ConfigTaskRsnTest.C b/PWG2/RESONANCES/doc/ConfigTaskRsnTest.C
new file mode 120000 (symlink)
index 0000000..2891b59
--- /dev/null
@@ -0,0 +1 @@
+../macros/test/ConfigTaskRsnTest.C
\ No newline at end of file
diff --git a/PWG2/RESONANCES/doc/rsndoc.aux b/PWG2/RESONANCES/doc/rsndoc.aux
new file mode 100644 (file)
index 0000000..d23635f
--- /dev/null
@@ -0,0 +1,3 @@
+\relax 
+\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{1}}
+\@writefile{toc}{\contentsline {section}{\numberline {2}Cuts}{3}}
diff --git a/PWG2/RESONANCES/doc/rsndoc.log b/PWG2/RESONANCES/doc/rsndoc.log
new file mode 100644 (file)
index 0000000..8eb8377
--- /dev/null
@@ -0,0 +1,162 @@
+This is pdfTeX, Version 3.1415926-1.40.10 (TeX Live 2009/Debian) (format=pdflatex 2010.8.26)  22 SEP 2010 10:24
+entering extended mode
+ restricted \write18 enabled.
+ %&-line parsing enabled.
+**rsndoc.tex
+(./rsndoc.tex
+LaTeX2e <2009/09/24>
+Babel <v3.8l> and hyphenation patterns for english, usenglishmax, dumylang, noh
+yphenation, loaded.
+(/usr/share/texmf-texlive/tex/latex/base/article.cls
+Document Class: article 2007/10/19 v1.4h Standard LaTeX document class
+(/usr/share/texmf-texlive/tex/latex/base/size12.clo
+File: size12.clo 2007/10/19 v1.4h Standard LaTeX file (size option)
+)
+\c@part=\count79
+\c@section=\count80
+\c@subsection=\count81
+\c@subsubsection=\count82
+\c@paragraph=\count83
+\c@subparagraph=\count84
+\c@figure=\count85
+\c@table=\count86
+\abovecaptionskip=\skip41
+\belowcaptionskip=\skip42
+\bibindent=\dimen102
+)
+(/usr/share/texmf-texlive/tex/latex/vmargin/vmargin.sty
+Package: vmargin 2004/07/15 V2.5 set document margins (VK)
+
+Package: vmargin 2004/07/15 V2.5 set document margins (VK)
+\PaperWidth=\dimen103
+\PaperHeight=\dimen104
+) (/usr/share/texmf-texlive/tex/latex/listings/listings.sty
+(/usr/share/texmf-texlive/tex/latex/graphics/keyval.sty
+Package: keyval 1999/03/16 v1.13 key=value parser (DPC)
+\KV@toks@=\toks14
+)
+\lst@mode=\count87
+\lst@gtempboxa=\box26
+\lst@token=\toks15
+\lst@length=\count88
+\lst@currlwidth=\dimen105
+\lst@column=\count89
+\lst@pos=\count90
+\lst@lostspace=\dimen106
+\lst@width=\dimen107
+\lst@newlines=\count91
+\lst@lineno=\count92
+\lst@maxwidth=\dimen108
+
+(/usr/share/texmf-texlive/tex/latex/listings/lstmisc.sty
+File: lstmisc.sty 2007/02/22 1.4 (Carsten Heinz)
+\c@lstnumber=\count93
+\lst@skipnumbers=\count94
+\lst@framebox=\box27
+)
+(/usr/share/texmf-texlive/tex/latex/listings/listings.cfg
+File: listings.cfg 2007/02/22 1.4 listings configuration
+))
+Package: listings 2007/02/22 1.4 (Carsten Heinz)
+ (./rsndoc.aux)
+\openout1 = `rsndoc.aux'.
+
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 16.
+LaTeX Font Info:    ... okay on input line 16.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 16.
+LaTeX Font Info:    ... okay on input line 16.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 16.
+LaTeX Font Info:    ... okay on input line 16.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 16.
+LaTeX Font Info:    ... okay on input line 16.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 16.
+LaTeX Font Info:    ... okay on input line 16.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 16.
+LaTeX Font Info:    ... okay on input line 16.
+\c@lstlisting=\count95
+
+(/usr/share/texmf-texlive/tex/latex/listings/lstlang1.sty
+File: lstlang1.sty 2004/09/05 1.3 listings language file
+)
+(/usr/share/texmf-texlive/tex/latex/listings/lstlang1.sty
+File: lstlang1.sty 2004/09/05 1.3 listings language file
+)
+(/usr/share/texmf-texlive/tex/latex/listings/lstmisc.sty
+File: lstmisc.sty 2007/02/22 1.4 (Carsten Heinz)
+)
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <14.4> on input line 20.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <7> on input line 20.
+
+
+LaTeX Font Warning: Font shape `OT1/cmss/m/it' in size <6> not available
+(Font)              Font shape `OT1/cmss/m/sl' tried instead on input line 45.
+
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <6> on input line 51.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <5> on input line 51.
+LaTeX Font Info:    Try loading font information for OMS+cmss on input line 52.
+
+LaTeX Font Info:    No file OMScmss.fd. on input line 52.
+
+LaTeX Font Warning: Font shape `OMS/cmss/m/it' undefined
+(Font)              using `OMS/cmsy/m/n' instead
+(Font)              for symbol `textbraceleft' on input line 52.
+
+
+LaTeX Font Warning: Font shape `OMS/cmss/m/n' undefined
+(Font)              using `OMS/cmsy/m/n' instead
+(Font)              for symbol `textasteriskcentered' on input line 60.
+
+[1
+
+{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}]
+LaTeX Font Info:    Try loading font information for OML+cmss on input line 85.
+
+LaTeX Font Info:    No file OMLcmss.fd. on input line 85.
+
+
+LaTeX Font Warning: Font shape `OML/cmss/m/it' undefined
+(Font)              using `OML/cmm/m/it' instead
+(Font)              for symbol `textgreater' on input line 85.
+
+
+LaTeX Font Warning: Font shape `OML/cmss/m/n' undefined
+(Font)              using `OML/cmss/m/it' instead
+(Font)              for symbol `textgreater' on input line 108.
+
+[2]
+
+LaTeX Font Warning: Font shape `OT1/cmss/m/it' in size <12> not available
+(Font)              Font shape `OT1/cmss/m/sl' tried instead on input line 249.
+
+
+[3] [4] (./rsndoc.aux)
+
+LaTeX Font Warning: Some font shapes were not available, defaults substituted.
+
+ ) 
+Here is how much of TeX's memory you used:
+ 1952 strings out of 495061
+ 27415 string characters out of 1182621
+ 185396 words of memory out of 3000000
+ 5170 multiletter control sequences out of 15000+50000
+ 9218 words of font info for 33 fonts, out of 3000000 for 9000
+ 28 hyphenation exceptions out of 8191
+ 32i,6n,58p,465b,1584s stack positions out of 5000i,500n,10000p,200000b,50000s
+</usr/share/texmf-texlive/fonts/type1/public/amsfonts/cm/cmmi6.pfb></usr/shar
+e/texmf-texlive/fonts/type1/public/amsfonts/cm/cmss12.pfb></usr/share/texmf-tex
+live/fonts/type1/public/amsfonts/cm/cmss17.pfb></usr/share/texmf-texlive/fonts/
+type1/public/amsfonts/cm/cmss8.pfb></usr/share/texmf-texlive/fonts/type1/public
+/amsfonts/cm/cmssbx10.pfb></usr/share/texmf-texlive/fonts/type1/public/amsfonts
+/cm/cmssi12.pfb></usr/share/texmf-texlive/fonts/type1/public/amsfonts/cm/cmssi8
+.pfb></usr/share/texmf-texlive/fonts/type1/public/amsfonts/cm/cmsy6.pfb></usr/s
+hare/texmf-texlive/fonts/type1/public/amsfonts/cm/cmtt12.pfb>
+Output written on rsndoc.pdf (4 pages, 124339 bytes).
+PDF statistics:
+ 51 PDF objects out of 1000 (max. 8388607)
+ 0 named destinations out of 1000 (max. 500000)
+ 1 words of extra memory for PDF output out of 10000 (max. 10000000)
+
diff --git a/PWG2/RESONANCES/doc/rsndoc.nav b/PWG2/RESONANCES/doc/rsndoc.nav
new file mode 100644 (file)
index 0000000..e72d4cc
--- /dev/null
@@ -0,0 +1,14 @@
+\beamer@endinputifotherversion {3.07pt}
+\headcommand {\slideentry {0}{0}{1}{1/1}{}{0}}
+\headcommand {\beamer@framepages {1}{1}}
+\headcommand {\sectionentry {1}{Introduction}{2}{Introduction}{0}}
+\headcommand {\beamer@sectionpages {1}{1}}
+\headcommand {\beamer@subsectionpages {1}{1}}
+\headcommand {\sectionentry {2}{Cuts}{3}{Cuts}{0}}
+\headcommand {\beamer@sectionpages {2}{2}}
+\headcommand {\beamer@subsectionpages {2}{2}}
+\headcommand {\beamer@partpages {1}{5}}
+\headcommand {\beamer@subsectionpages {3}{5}}
+\headcommand {\beamer@sectionpages {3}{5}}
+\headcommand {\beamer@documentpages {5}}
+\headcommand {\def \inserttotalframenumber {1}}
diff --git a/PWG2/RESONANCES/doc/rsndoc.out b/PWG2/RESONANCES/doc/rsndoc.out
new file mode 100644 (file)
index 0000000..1f9a6d2
--- /dev/null
@@ -0,0 +1,2 @@
+\BOOKMARK [2][]{Outline0.1}{Introduction}{}
+\BOOKMARK [2][]{Outline0.2}{Cuts}{}
diff --git a/PWG2/RESONANCES/doc/rsndoc.pdf b/PWG2/RESONANCES/doc/rsndoc.pdf
new file mode 100644 (file)
index 0000000..974a415
Binary files /dev/null and b/PWG2/RESONANCES/doc/rsndoc.pdf differ
diff --git a/PWG2/RESONANCES/doc/rsndoc.snm b/PWG2/RESONANCES/doc/rsndoc.snm
new file mode 100644 (file)
index 0000000..e69de29
diff --git a/PWG2/RESONANCES/doc/rsndoc.tex b/PWG2/RESONANCES/doc/rsndoc.tex
new file mode 100644 (file)
index 0000000..1145cff
--- /dev/null
@@ -0,0 +1,270 @@
+\documentclass[12pt,a4paper]{article}
+
+\usepackage{vmargin}
+\usepackage{listings}
+
+\renewcommand{\rmdefault}{cmss}
+\newcommand{\inlinecode}[2]{\mbox{{\bf #1(}#2{\bf)}}}
+
+\setpapersize{A4}
+\setmarginsrb{10mm}{10mm}{10mm}{10mm}{0mm}{10mm}{0mm}{10mm}
+
+\title{ALICE resonance analysis package documentation}
+\author{A. Pulvirenti}
+\date{\tt alberto.pulvirenti@ct.infn.it}
+
+\begin{document}
+\lstset{language=C++}
+\lstset{basicstyle=\tiny}
+
+\maketitle
+
+\section{Introduction}
+
+This small guide will drive the user through the resonance analysis package (we'll call it RSN), in order to learn how to configure an analysis with it and how to personalize some of its aspects.
+A slightly more advanced reference guide will also be provided at the end; it is of interest especially to all people interested in contributing to the package development, in order to go in a major detail through the code.
+
+The purpose of the package is to set up an AnalysisTask object for resonance analysis.
+Then, all of its objects aim at configuring it properly for a specific resonance study.
+Keeping in mind this main purpose, we will explain how to configure a typical analysis, and this will give the possibility to introduce the user to all package classes he will have to manage directly.
+This will be done just going through a typical configuration macro, and discussing its lines.
+
+This guide assumes that the reader roughly knows how a typical aliroot AnalysisTask object should be initialized, so we will not spend much time on its general aspects (how to configure input handlers and output containers, how to setup the AnalysisManager etc.\,).
+Anyway, in  the{\tt PWG2/RESONANCES/macros/test} path (inside the aliroot soruce code tree), it is available a set of macroes which can be used to steer an analysis from an aliroot session.
+
+We will then give the initial description following a building scheme where we go through all aspects of analysis initialization.
+The package is based on four independent pieces which all contribute to the final analysis:
+the interface classes which are used to uniformize the way it accesses the informations taken from whatever kind of input source (namely, ESD, AOD or MC);
+the work-flow classes which just execute the loops on the events and build up the output objects returned by the analysis task;
+the cut classes which are the fundamental step for track/pair selection and can determine the difference between one analysis and another
+the  output classes which implement the computation of all output values of interest
+It must be specified that, in its current version, the package is built essentially in order to make computations on pairs of particles, when they are accepted as a candidate resonance decay.
+This document will give a panoramic of all the classes which are currently available in the package, specifying what they are implemented for. Anyway, not all of the package classes need to be perfectly known by the user, since most of them implement just the necessary internal steps to loop on the event and produce the output. Whenever a class enters the necessary configuration and needs to be managed by the user, more details will be given to it.
+Finally, we must mention that the package is currently built in such a way that it allows an advanced user to customize some aspects of the analysis.
+\begin{lstlisting}[frame=single]
+//
+// This function configures the entire task for all resonances the user is interested in.
+// This is done by creating all configuration objects which are defined in the package.
+//
+// Generally speaking, one has to define the following objects for each resonance:
+//
+//  1 - an AliRsnPairDef to define the resonance decay channel to be studied
+//  2 - an AliRsnPair{Ntuple|Functions} where the output is stored
+//  3 - one or more AliRsnCut objects to define track selections
+//      which will have then to be organized into AliRsnCutSet objects
+//  4 - an AliRsnCutManager to include all cuts to be applied (see point 3)
+//  5 - definitions to build the TNtuple or histograms which are returned
+//
+// The return value is used to know if the configuration was successful
+//
+Bool_t RsnConfigTask(AliRsnAnalysisSE* &task, const char *dataLabel)
+{
+  // for safety, return if no task is passed
+  if (!task)
+  {
+    Error("ConfigTaskRsn", "Task not found");
+    return kFALSE;
+  }
+  
+  // interpret the useful information from second argument
+  TString strDataLabel(dataLabel);
+  Bool_t isESD   = strDataLabel.Contains("ESD");
+  Bool_t isAOD   = strDataLabel.Contains("AOD");
+  Bool_t isSim   = strDataLabel.Contains("sim");
+  Bool_t isData  = strDataLabel.Contains("data");
+  Bool_t isPass1 = strDataLabel.Contains("pass1");
+  Bool_t isPass2 = strDataLabel.Contains("pass2");
+
+  //
+  // -- Set cuts for events (applied to all analyses) -----------------------------------------------
+  //
+  
+  // primary vertex range
+  AliRsnCutPrimaryVertex *cutVertex   = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
+  AliRsnCutSet           *cutSetEvent = new AliRsnCutSet("eventCuts", AliRsnCut::kEvent);
+  //cutSetEvent->AddCut(cutVertex);
+  //cutSetEvent->SetCutScheme("cutVertex");
+  //task->SetEventCuts(cutSetEvent);
+
+  //
+  // -- Setup pairs ---------------------------------------------------------------------------------
+  //
+
+  // decay channels
+  AliRsnPairDef         *pairDefpm = new AliRsnPairDef(AliPID::kKaon, '+', AliPID::kKaon, '-', 333, 1.019455);
+
+  // computation objects
+  AliRsnPairFunctions   *pairPMhist = new AliRsnPairFunctions("pairPMHist", pairDefpm);
+  AliRsnPairNtuple      *pairPMntp  = new AliRsnPairNtuple   ("pairPMNtp" , pairDefpm);
+
+  //
+  // -- Setup cuts ----------------------------------------------------------------------------------
+  //
+  
+  // -- track cut --
+  // --> global cuts for 2010 analysis
+  AliRsnCutESD2010 *cuts2010 = new AliRsnCutESD2010("cuts2010");
+  // ----> set the flag for sim/data management
+  cuts2010->SetMC(isSim);
+  // ----> require to check PID
+  cuts2010->SetCheckITS(kFALSE);
+  cuts2010->SetCheckTPC(kFALSE);
+  cuts2010->SetCheckTOF(kFALSE);
+  // ----> set TPC ranges and calibration
+  cuts2010->SetTPCrange(5.0, 3.0);
+  cuts2010->SetTPCpLimit(0.35);
+  cuts2010->SetITSband(4.0);
+  if (isSim) cuts2010->SetTPCpar(2.15898 / 50.0, 1.75295E1, 3.40030E-9, 1.96178, 3.91720);
+  else       cuts2010->SetTPCpar(1.41543 / 50.0, 2.63394E1, 5.0411E-11, 2.12543, 4.88663);
+  // ----> set standard quality cuts for TPC global tracks
+  //cuts2010->GetCutsTPC()->SetRequireTPCStandAlone(kTRUE); // require to have the projection at inner TPC wall
+  cuts2010->GetCutsTPC()->SetMinNClustersTPC(70);
+  cuts2010->GetCutsTPC()->SetMaxChi2PerClusterTPC(4);
+  cuts2010->GetCutsTPC()->SetAcceptKinkDaughters(kFALSE);
+  cuts2010->GetCutsTPC()->SetRequireTPCRefit(kTRUE);
+  cuts2010->GetCutsTPC()->SetRequireITSRefit(kTRUE);
+  cuts2010->GetCutsTPC()->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
+  cuts2010->GetCutsTPC()->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9"); // DCA pt dependent: 7*(0.0050+0.0060/pt0.9)
+  cuts2010->GetCutsTPC()->SetMaxDCAToVertexZ(1e6); // disabled
+  cuts2010->GetCutsTPC()->SetDCAToVertex2D(kFALSE); // each DCA is checked separately
+  cuts2010->GetCutsTPC()->SetRequireSigmaToVertex(kFALSE);
+  // ----> set standard quality cuts for ITS standalone tracks
+  cuts2010->GetCutsITS()->SetRequireITSStandAlone(kTRUE, kTRUE);
+  cuts2010->GetCutsITS()->SetRequireITSRefit(kTRUE);
+  cuts2010->GetCutsITS()->SetMinNClustersITS(4);
+  cuts2010->GetCutsITS()->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
+  cuts2010->GetCutsITS()->SetMaxChi2PerClusterITS(1.);
+  cuts2010->GetCutsITS()->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55"); // DCA pt dependent
+  cuts2010->GetCutsITS()->SetMaxDCAToVertexZ(1e6); // disabled
+  cuts2010->GetCutsITS()->SetDCAToVertex2D(kFALSE); // each DCA is checked separately
+  // ----> set the configuration for TOF PID checks
+  if (isData && (isPass1 || isPass2))
+  {
+    cuts2010->SetTOFcalibrateESD(kTRUE);
+    //if (isPass2) cuts2010->SetTOFcalibrateESD(kFALSE); // potrebbe anche essere kFALSE
+    cuts2010->SetTOFcorrectTExp(kTRUE);
+    cuts2010->SetTOFuseT0(kTRUE);
+    cuts2010->SetTOFtuneMC(kFALSE);
+    cuts2010->SetTOFresolution(100.0);
+  }
+  else if (isSim)
+  {
+    cuts2010->SetTOFcalibrateESD(kFALSE);
+    cuts2010->SetTOFcorrectTExp(kTRUE);
+    cuts2010->SetTOFuseT0(kTRUE);
+    cuts2010->SetTOFtuneMC(kTRUE);
+    cuts2010->SetTOFresolution(100.0);
+  }
+  
+  // -- tracks --> PID
+  AliRsnCutPID *cutPID = new AliRsnCutPID("cutPID", AliPID::kKaon, 0.0, kTRUE);
+  
+  // cut sets
+  AliRsnCutSet *cutSetDaughterCommon = new AliRsnCutSet("commonDaughterCuts", AliRsnCut::kDaughter);
+
+  // --> add related cuts
+  //cutSetDaughterCommon->AddCut(cuts2010);
+  cutSetDaughterCommon->AddCut(cutPID);
+
+  // --> define schemes
+  cutSetDaughterCommon->SetCutScheme("cutPID");
+   
+  // cut managers
+  // define a proper name for each mult bin, to avoid omonyme output histos
+  pairPMhist->GetCutManager()->SetCommonDaughterCuts(cutSetDaughterCommon);
+  pairPMntp ->GetCutManager()->SetCommonDaughterCuts(cutSetDaughterCommon);
+
+  // function axes
+  Double_t ybins[] = {-0.8, -0.7, -0.6, -0.5, 0.5, 0.6, 0.7, 0.8};
+  AliRsnValue *axisIM   = new AliRsnValue("IM"  , AliRsnValue::kPairInvMass, 50,  0.9,  1.4);
+  AliRsnValue *axisPt   = new AliRsnValue("PT"  , AliRsnValue::kPairPt,      0.0, 20.0, 0.1);
+  AliRsnValue *axisY    = new AliRsnValue("Y"   , AliRsnValue::kPairY,       sizeof(ybins)/sizeof(ybins[0]), ybins);
+  AliRsnValue *axisQinv = new AliRsnValue("QInv", AliRsnValue::kQInv,       100,  0.0, 10.0);
+
+  // functions for TH1-like output
+  AliRsnFunction *fcnPt    = new AliRsnFunction;
+  // --> add axes
+  fcnPt   ->AddAxis(axisIM);
+  fcnPt   ->AddAxis(axisPt);
+  fcnPt   ->AddAxis(axisY);
+  fcnPt   ->AddAxis(axisQinv);
+  
+  // add functions to TH1-like output
+  pairPMhist->AddFunction(fcnPt);
+  //pairPMhist->SetOnlyTrue();
+  
+  // add values to TNtuple-like output
+  pairPMntp->AddValue(axisIM);
+  pairPMntp->AddValue(axisPt);
+  pairPMntp->AddValue(axisY);
+  pairPMntp->AddValue(axisQinv);
+  
+  // add everything to analysis manager
+  task->GetAnalysisManager()->Add(pairPMhist);
+  task->GetAnalysisManager()->Add(pairPMntp);
+
+  return kTRUE;
+}
+\end{lstlisting}
+
+\section{Cuts}
+
+Cuts are implemented in the package through the {\bf AliRsnCut} base class, which is the basic scheme from which all specific cut implementations must inherit.
+Its general structure is given here:
+%
+\begin{lstlisting}[frame=single]
+class AliRsnCut : public TNamed
+{
+  public:
+
+    ...
+
+    virtual Bool_t   IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+
+    ...
+
+  protected:
+
+    Bool_t  OkValue();
+    Bool_t  OkRange();
+    Bool_t  OkValueI();
+    Bool_t  OkRangeI();
+    Bool_t  OkValueD();
+    Bool_t  OkRangeD();
+    
+    ...
+
+    Int_t     fMinI;       // lower edge of INT range or ref. value for INT CUT
+    Int_t     fMaxI;       // upper edge of INT range (not used for value cuts)
+    Double_t  fMinD;       // lower edge of DOUBLE range or ref. value for INT CUT
+    Double_t  fMaxD;       // upper edge of DOUBLE range (not used for value cuts)
+
+    Int_t     fCutValueI;  // cut value INT
+    Double_t  fCutValueD;  // cut value DOUBLE
+    
+    ...
+};
+\end{lstlisting}
+%
+The heart of the class definition is the \inlinecode{IsSelected}{} function, which is called when the cut needs to be checked along the work-flow of the analysis and {\em must} be overloaded by each specific cut implementations inheriting from this base class.
+Due to this structure, a user can implement his personalized version of the cuts by creating a class inheriting from {\bf AliRsnCut} and compiling it on the fly, and using it in the standard analysis.
+
+Most cuts usually consist in checking that a value equals a given reference or stays inside a given range.
+Then, we provide directly in the base class the instruments to make these checks with integer or floating-point variables.
+One thing that needs to be considered here is that, for monitoring purposes, these value or range check functions (\inlinecode{OkValueD}{}, \inlinecode{OkValueI}{}, \inlinecode{OkRangeD}{} and \inlinecode{OkRangeI}{}) do not accept arguments, since the value to be checked is expected to be stored in an apposite data member of the class itself ({\bf fCutValueI} and {\bf fCutValueD}).
+Then, all cuts which exploit this facility must first store the value to be checked in these data members and then call the corresponding range or value check function.
+The advantage of this structure is that the cut value can be kept in memory and, for example, monitored using debug messages.
+
+Since usually a user does many checks and sometimes the way to link cuts together is not exactly their simple ``and'', then we introduced a strategy which allows to implement each single check separately, with the advantage of having simpler code, easier to debug.
+This strategy is based on the {\bf AliRsnCutSet} class, which acts as a collector of cuts.
+All points where a cut check is done throughout the analysis work-flow uses object of this type, instead of accessing direcly to the single cuts.
+With this object a user has to do two things: first, add all cuts he wants to check; second, defining a logic by means of a string containing an expression where the names of the single cuts are combined using the C++ logic operators (and, or not). 
+Both these steps are necessary, since if one just adds the cuts but does not define a logic, then no cut check is taken into account.
+On the other side, for ease of use, one can add cuts and not use them, since it is not mandatory to include all cut names inside the logic. 
+Anywaym the user must keep in mind that all cuts added to a set are checked always, so, adding  a lot of unused cuts could unnecessarily slow down the analysis execution.
+
+The uppermost step of the cut structure is the {\bf AliRsnCutManager}, which combines a set for each possible object to check.
+
+
+
+\end{document}
diff --git a/PWG2/RESONANCES/doc/rsndoc.toc b/PWG2/RESONANCES/doc/rsndoc.toc
new file mode 100644 (file)
index 0000000..bcdb7dd
--- /dev/null
@@ -0,0 +1,3 @@
+\beamer@endinputifotherversion {3.07pt}
+\beamer@sectionintoc {1}{Introduction}{2}{0}{1}
+\beamer@sectionintoc {2}{Cuts}{3}{0}{2}
diff --git a/PWG2/RESONANCES/macros/test/AddAnalysisTaskRsnEff.C b/PWG2/RESONANCES/macros/test/AddAnalysisTaskRsnEff.C
new file mode 100644 (file)
index 0000000..8acc451
--- /dev/null
@@ -0,0 +1,142 @@
+//
+// This macro add an analysis task for computing efficiency.
+// It will have as output an AliCFContainer with several steps:
+//
+//  0) all resonances in MC which decay in the pair specified
+//  1) all resonances in ESD (i.e.: reconstruction/acceptance effect)
+//  2) subset of (1) whose daughters satisfy quality track cuts (covariance, chi square && nTPCclusters, DCA)
+//  3) subset of (2) whose daughters satisty the PID cuts
+//
+Bool_t AddAnalysisTaskRsnEff(const char *dataLabel)
+{
+  // retrieve analysis manager
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+  
+  // create task
+  AliRsnAnalysisEffSE *task = new AliRsnAnalysisEffSE("phiEff");
+
+  // pair definitions:
+  // phi --> K+ K-
+  AliRsnPairDef *pairPhi = new AliRsnPairDef(AliPID::kKaon, '+', AliPID::kKaon, '-', 333, 1.019455);
+  task->AddPairDef(pairPhi);
+
+  // axis definition
+  //  0) transverse momentum (fixed bins of 100 MeV/c)
+  //  1) rapidity (variable bins)
+  //  2) invariant mass (fixed bins of 1 MeV/c^2)
+  Double_t y[] = {-0.8, -0.7, -0.6, -0.5, 0.5, 0.6, 0.7, 0.8};
+  Int_t    ny  = sizeof(y) / sizeof(y[0]);
+  AliRsnValue *axisIM = new AliRsnValue("IM", AliRsnValue::kPairInvMass, 500, 0.9,  1.4);
+  AliRsnValue *axisPt = new AliRsnValue("PT", AliRsnValue::kPairPt     , 100, 0.0, 10.0);
+  AliRsnValue *axisY  = new AliRsnValue("Y" , AliRsnValue::kPairY      ,  ny, y);
+  task->AddAxis(axisIM);
+  task->AddAxis(axisPt);
+  task->AddAxis(axisY);
+
+  // define cuts for event selection:
+  // this will determine the filling of bins in the "info" histograms
+  // and should be computed as additional correction factor in efficiency
+  AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
+  task->GetEventCuts()->AddCut(cutVertex);
+  task->GetEventCuts()->SetCutScheme("cutVertex");
+
+  //
+  // *** STEP 0 - All resonances which decay in the specified pairs
+  //
+  // This step does not need any kind of definition, since
+  // its requirement is automatically checked during execution,
+  // but a cut manager needs to be defined at each step, even if empty.
+  //
+  AliRsnCutManager *mgr_step0 = new AliRsnCutManager("mc_step0", "");
+  
+  // add this as a step on MonteCarlo
+  task->AddStepMC (mgr_step0);
+  
+  //
+  // *** STEP 1 - All resonances which decay into tracked particles
+  //
+  // This step does not need any kind of definition, since
+  // its requirement is automatically checked during execution,
+  // but a cut manager needs to be defined at each step, even if empty.
+  //
+  AliRsnCutManager *mgr_step1 = new AliRsnCutManager("mc_step0", "");
+  
+  // add this as a step on reconstructed tracks
+  task->AddStepESD(mgr_step1);
+  
+  //
+  // *** STEP 2 - Track quality
+  //
+  
+  // track cut -----------------------
+  // --> global cuts for 2010 analysis
+  AliRsnCutESD2010 *cuts2010 = new AliRsnCutESD2010("cutESD2010");
+  // ----> set the flag for sim management
+  cuts2010->SetMC(kTRUE);
+  // ----> disable checking of PID, but include also ITS stand-alone
+  cuts2010->SetCheckITS (kFALSE);
+  cuts2010->SetCheckTPC (kFALSE);
+  cuts2010->SetCheckTOF (kFALSE);
+  cuts2010->SetUseGlobal(kTRUE);
+  cuts2010->SetUseITSSA (kTRUE);
+  // ----> set defaults for the rest
+  cuts2010->InitializeToDefaults(kTRUE);
+  
+  // cut sets ---------------------------------
+  // --> only common cuts for tracks are needed
+  // --> standard 2010 cuts are applied only when working on ESD
+  AliRsnCutSet *cutSetDaughterCommon_step2 = new AliRsnCutSet("commonDaughterCuts_step2", AliRsnCut::kDaughter);
+  cutSetDaughterCommon_step2->AddCut(cuts2010);
+  cutSetDaughterCommon_step2->SetCutScheme(cuts2010->GetName());
+  AliRsnCutManager *mgr_step2   = new AliRsnCutManager("esd_step2", "");
+  mgr_step2->SetCommonDaughterCuts(cutSetDaughterCommon_step2);
+  
+  // add this as a step on reconstructed tracks
+  task->AddStepESD(mgr_step2);
+  
+  //
+  // *** STEP 3 - PID
+  //
+  
+  // track cut -----------------------
+  // --> global cuts for 2010 analysis
+  AliRsnCutESD2010 *cuts2010_pid = new AliRsnCutESD2010("cutESD2010_pid");
+  // ----> set the flag for sim/data management
+  cuts2010_pid->SetMC(kTRUE);
+  // ----> enable PID checking
+  cuts2010_pid->SetCheckITS (kTRUE);
+  cuts2010_pid->SetCheckTPC (kTRUE);
+  cuts2010_pid->SetCheckTOF (kTRUE);
+  cuts2010_pid->SetUseGlobal(kTRUE);
+  cuts2010_pid->SetUseITSSA (kTRUE);
+  // ----> set defaults for the rest
+  cuts2010_pid->InitializeToDefaults(kTRUE);
+  
+  // cut sets ---------------------------------
+  // --> only common cuts for tracks are needed
+  // --> standard 2010 cuts are applied only when working on ESD
+  AliRsnCutSet *cutSetDaughterCommon_step3 = new AliRsnCutSet("commonDaughterCuts_step3", AliRsnCut::kDaughter);
+  cutSetDaughterCommon_step3->AddCut(cuts2010_pid);
+  cutSetDaughterCommon_step3->SetCutScheme(cuts2010_pid->GetName());
+  AliRsnCutManager *mgr_step3   = new AliRsnCutManager("esd_step3", "");
+  mgr_step3->SetCommonDaughterCuts(cutSetDaughterCommon_step3);
+
+  // add this as a step on reconstructed tracks
+  task->AddStepESD(mgr_step3);
+
+  // add task to manager and setup containers
+  mgr->AddTask(task);
+  mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+  
+  // create paths for the output in the common file
+  Char_t commonPath[500];
+  sprintf(commonPath, "%s", AliAnalysisManager::GetCommonFileName());
+
+  // create paths for the output in the common file
+  AliAnalysisDataContainer *outputInfo = mgr->CreateContainer("RsnInfoEff", TList::Class(), AliAnalysisManager::kOutputContainer, commonPath);
+  AliAnalysisDataContainer *outputHist = mgr->CreateContainer("RsnEff" , TList::Class(), AliAnalysisManager::kOutputContainer, commonPath);
+  mgr->ConnectOutput(task, 1, outputInfo);
+  mgr->ConnectOutput(task, 2, outputHist);
+
+  return kTRUE;
+}
index 0f1dc2c..8b16279 100644 (file)
@@ -3,6 +3,8 @@
 SRCS= RESONANCES/AliRsnDaughter.cxx \
       RESONANCES/AliRsnMother.cxx \
       RESONANCES/AliRsnEvent.cxx \
+      RESONANCES/AliRsnValue.cxx \
+      RESONANCES/AliRsnFunction.cxx \
       RESONANCES/AliRsnExpression.cxx \
       RESONANCES/AliRsnVariableExpression.cxx \
       RESONANCES/AliRsnCut.cxx \
@@ -14,9 +16,8 @@ SRCS= RESONANCES/AliRsnDaughter.cxx \
       RESONANCES/AliRsnCutDaughterType.cxx \
       RESONANCES/AliRsnCutESD2010.cxx \
       RESONANCES/AliRsnCutSet.cxx \
+      RESONANCES/AliRsnCutValue.cxx \
       RESONANCES/AliRsnCutManager.cxx \
-      RESONANCES/AliRsnValue.cxx \
-      RESONANCES/AliRsnFunction.cxx \
       RESONANCES/AliRsnPairDef.cxx \
       RESONANCES/AliRsnPair.cxx \
       RESONANCES/AliRsnPairFunctions.cxx \