Fixed all fixable coding conventions violations
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 14 Jun 2011 15:58:23 +0000 (15:58 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 14 Jun 2011 15:58:23 +0000 (15:58 +0000)
49 files changed:
PWG2/CMakelibPWG2resonances.pkg
PWG2/PWG2resonancesLinkDef.h
PWG2/RESONANCES/AliRsnCut.h
PWG2/RESONANCES/AliRsnCutMiniPair.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutMiniPair.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutPID.cxx
PWG2/RESONANCES/AliRsnCutPID.h
PWG2/RESONANCES/AliRsnCutPIDITS.cxx
PWG2/RESONANCES/AliRsnCutPIDITS.h
PWG2/RESONANCES/AliRsnCutPIDNSigma.h
PWG2/RESONANCES/AliRsnCutPIDTPC.cxx
PWG2/RESONANCES/AliRsnCutPIDTPC.h
PWG2/RESONANCES/AliRsnCutPrimaryVertex.h
PWG2/RESONANCES/AliRsnCutSet.cxx
PWG2/RESONANCES/AliRsnCutSet.h
PWG2/RESONANCES/AliRsnCutTrackQuality.h
PWG2/RESONANCES/AliRsnCutTrue.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutTrue.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutValue.cxx
PWG2/RESONANCES/AliRsnCutValue.h
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnDaughterDef.h
PWG2/RESONANCES/AliRsnDaughterSelector.cxx
PWG2/RESONANCES/AliRsnDaughterSelector.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnInputHandler.cxx
PWG2/RESONANCES/AliRsnInputHandler.h
PWG2/RESONANCES/AliRsnListOutput.cxx
PWG2/RESONANCES/AliRsnListOutput.h
PWG2/RESONANCES/AliRsnLoop.h
PWG2/RESONANCES/AliRsnLoopDaughter.cxx
PWG2/RESONANCES/AliRsnLoopDaughter.h
PWG2/RESONANCES/AliRsnLoopEff.cxx
PWG2/RESONANCES/AliRsnLoopEff.h
PWG2/RESONANCES/AliRsnLoopEffDaughter.cxx
PWG2/RESONANCES/AliRsnLoopEffPair.cxx
PWG2/RESONANCES/AliRsnLoopEffPair.h
PWG2/RESONANCES/AliRsnLoopEvent.cxx
PWG2/RESONANCES/AliRsnLoopEvent.h
PWG2/RESONANCES/AliRsnLoopPair.cxx
PWG2/RESONANCES/AliRsnLoopPair.h
PWG2/RESONANCES/AliRsnMother.cxx
PWG2/RESONANCES/AliRsnMother.h
PWG2/RESONANCES/AliRsnTarget.h
PWG2/RESONANCES/AliRsnValueDaughter.cxx
PWG2/RESONANCES/AliRsnValueDaughter.h
PWG2/RESONANCES/AliRsnValuePair.cxx
PWG2/RESONANCES/AliRsnValuePair.h

index 17d1a82..bd4f12f 100644 (file)
@@ -38,6 +38,7 @@ set ( SRCS RESONANCES/AliRsnDaughter.cxx
            RESONANCES/AliRsnValueEvent.cxx
            RESONANCES/AliRsnCutPrimaryVertex.cxx
            RESONANCES/AliRsnCutTrackQuality.cxx
+           RESONANCES/AliRsnCutTrue.cxx
            RESONANCES/AliRsnCutValue.cxx
            RESONANCES/AliRsnCutPID.cxx
            RESONANCES/AliRsnCutPIDITS.cxx
@@ -47,6 +48,8 @@ set ( SRCS RESONANCES/AliRsnDaughter.cxx
            RESONANCES/AliRsnCutMomentumComparison.cxx
            RESONANCES/AliRsnCutKaonForPhi2010.cxx
            RESONANCES/AliRsnCutKaonForPhi2010PP.cxx
+           RESONANCES/AliRsnCutPion2010PP.cxx
+           RESONANCES/AliRsnCutProton2010PP.cxx
            RESONANCES/AliRsnCutSet.cxx
            RESONANCES/AliRsnExpression.cxx
            RESONANCES/AliRsnVariableExpression.cxx
@@ -60,7 +63,15 @@ set ( SRCS RESONANCES/AliRsnDaughter.cxx
            RESONANCES/AliRsnLoopEffPair.cxx
            RESONANCES/AliRsnDaughterSelector.cxx
            RESONANCES/AliRsnInputHandler.cxx
-           RESONANCES/AliRsnAnalysisTask.cxx )
+           RESONANCES/AliRsnAnalysisTask.cxx
+           RESONANCES/AliRsnMiniParticle.cxx
+           RESONANCES/AliRsnMiniPair.cxx
+           RESONANCES/AliRsnCutMiniPair.cxx
+           RESONANCES/AliRsnMiniEvent.cxx
+           RESONANCES/AliRsnMiniAxis.cxx
+           RESONANCES/AliRsnMiniOutput.cxx
+           RESONANCES/AliRsnMiniValue.cxx
+           RESONANCES/AliRsnMiniAnalysisTask.cxx )
 
 string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
index 02fec9c..c4bf801 100644 (file)
@@ -16,6 +16,7 @@
 #pragma link C++ class AliRsnValueEvent+;
 
 #pragma link C++ class AliRsnCutPrimaryVertex+;
+#pragma link C++ class AliRsnCutTrue+;
 #pragma link C++ class AliRsnCutTrackQuality+;
 #pragma link C++ class AliRsnCutValue+;
 #pragma link C++ class AliRsnCutPID+;
@@ -26,6 +27,9 @@
 #pragma link C++ class AliRsnCutMomentumComparison+;
 #pragma link C++ class AliRsnCutKaonForPhi2010+;
 #pragma link C++ class AliRsnCutKaonForPhi2010PP+;
+#pragma link C++ class AliRsnCutPion2010PP+;
+#pragma link C++ class AliRsnCutProton2010PP+;
+
 
 #pragma link C++ class AliRsnCutSet+;
 #pragma link C++ class AliRsnExpression+;
 #pragma link C++ class AliRsnInputHandler+;
 #pragma link C++ class AliRsnAnalysisTask+;
 
+#pragma link C++ class AliRsnMiniParticle+;
+#pragma link C++ class AliRsnMiniPair+;
+#pragma link C++ class AliRsnCutMiniPair+;
+#pragma link C++ class AliRsnMiniEvent+;
+#pragma link C++ class AliRsnMiniAxis+;
+#pragma link C++ class AliRsnMiniOutput+;
+#pragma link C++ class AliRsnMiniValue+;
+#pragma link C++ class AliRsnMiniAnalysisTask+;
+
+
 #endif
index e480091..1c42a47 100644 (file)
@@ -30,13 +30,13 @@ public:
    AliRsnCut& operator=(const AliRsnCut& copy);
    virtual ~AliRsnCut() { };
 
-   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;}
+   Int_t            GetMinI()      const {return fMinI;}
+   Int_t            GetMaxI()      const {return fMaxI;}
+   Double_t         GetMinD()      const {return fMinD;}
+   Double_t         GetMaxD()      const {return fMaxD;}
+   Int_t            GetCutValueI() const {return fCutValueI;}
+   Double_t         GetCutValueD() const {return fCutValueD;}
+   Bool_t           GetCutResult() const {return fCutResult;}
 
    void             SetRangeI(Int_t    min, Int_t    max) {fMinI = min; fMaxI = max;}
    void             SetRangeD(Double_t min, Double_t max) {fMinD = min; fMaxD = max;}
diff --git a/PWG2/RESONANCES/AliRsnCutMiniPair.cxx b/PWG2/RESONANCES/AliRsnCutMiniPair.cxx
new file mode 100644 (file)
index 0000000..e8f6225
--- /dev/null
@@ -0,0 +1,53 @@
+//
+// This cut definition works on mini-pairs for the 'mini' subpackage.
+// Since cuts on mini-pairs can usually be just kinematic selections
+// or kinematic comparisons between 4-momenta of daughters, they are all
+// implemented in this class, by the use of an enumeration which allows
+// the user to choose between all possibilities.
+//
+
+#include <Riostream.h>
+
+#include "AliRsnMiniPair.h"
+#include "AliRsnCutMiniPair.h"
+
+ClassImp(AliRsnCutMiniPair)
+
+//__________________________________________________________________________________________________
+AliRsnCutMiniPair::AliRsnCutMiniPair(const char *name, EType type) :
+   AliRsnCut(name, AliRsnTarget::kMother),
+   fType(type)
+{
+//
+// Constructor
+//
+}
+
+//__________________________________________________________________________________________________
+Bool_t AliRsnCutMiniPair::IsSelected(TObject *obj)
+{
+//
+// Global check
+//
+
+   AliRsnMiniPair *pair = dynamic_cast<AliRsnMiniPair*>(obj);
+   if (!pair) {
+      AliError("This cut applies only to mini-pairs");
+      return kFALSE;
+   }
+   
+   switch (fType) {
+      case kRapidityRange:
+         fCutValueD = pair->Y(0);
+         return OkRangeD();
+      case kRapidityRangeMC:
+         fCutValueD = pair->Y(1);
+         return OkRangeD();
+      case kMomentumComparison:
+         AliWarning("TODO: implement this");
+         return kTRUE;
+      default:
+         AliWarning("Undefined enum value");
+         return kTRUE;
+   }
+}
diff --git a/PWG2/RESONANCES/AliRsnCutMiniPair.h b/PWG2/RESONANCES/AliRsnCutMiniPair.h
new file mode 100644 (file)
index 0000000..f44a8c1
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALIRSNCUTMINIPAIR_H
+#define ALIRSNCUTMINIPAIR_H
+
+//
+// This cut definition works on mini-pairs for the 'mini' subpackage.
+// Since cuts on mini-pairs can usually be just kinematic selections
+// or kinematic comparisons between 4-momenta of daughters, they are all
+// implemented in this class, by the use of an enumeration which allows
+// the user to choose between all possibilities.
+//
+
+#include "AliRsnCut.h"
+
+class AliRsnCutMiniPair : public AliRsnCut {
+
+public:
+
+   enum EType {
+      kRapidityRange,
+      kRapidityRangeMC,
+      kMomentumComparison,
+      kTypes
+   };
+
+   AliRsnCutMiniPair(const char *name = "cut", EType type = kTypes);
+   virtual ~AliRsnCutMiniPair() { }
+   
+   virtual Bool_t IsSelected(TObject *obj);
+
+private:
+
+   EType fType;    // cut type
+
+   ClassDef(AliRsnCutMiniPair,1)
+
+};
+
+#endif
index da60801..db19945 100644 (file)
@@ -86,7 +86,7 @@ AliRsnCutPID::AliRsnCutPID(const char *name, AliPID::EParticleType pid, Double_t
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnCutPID::CheckThreshold(EDetector det, Double_t value)
+Bool_t AliRsnCutPID::CheckThreshold(EDetector det, Double_t value) const
 {
 //
 // Checks if the passed value (track pT) stays in the
index ac23189..772bca9 100644 (file)
@@ -43,14 +43,14 @@ public:
    Bool_t         ComputeWeights(AliRsnDaughter *daughter);
    Int_t          RealisticPID(AliRsnDaughter * const daughter, Double_t &prob);
    Int_t          PerfectPID(AliRsnDaughter * const daughter);
-   Double_t       GetWeight(Int_t i) {if (i >= 0 && i < AliPID::kSPECIES) return fWeight[i]; return 0.0;}
+   Double_t       GetWeight(Int_t i) const {if (i >= 0 && i < AliPID::kSPECIES) return fWeight[i]; return 0.0;}
 
    virtual Bool_t IsSelected(TObject *object);
 
 protected:
 
    Bool_t   CheckBounds(EDetector det) const {return (det >= kITS && det < kDetectors);}
-   Bool_t   CheckThreshold(EDetector det, Double_t value);
+   Bool_t   CheckThreshold(EDetector det, Double_t value) const;
 
    Double_t              fPrior[AliPID::kSPECIES];        // prior probability
    Double_t              fWeight[AliPID::kSPECIES];       // PID weights used for combinations
index cdce780..ba5a9b1 100644 (file)
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
+#include "AliESDtrackCuts.h"
+#include "AliAODpidUtil.h"
 #include "AliAnalysisManager.h"
 #include "AliESDInputHandler.h"
 
+#include "AliRsnDaughter.h"
+
 #include "AliRsnCutPIDITS.h"
 
 ClassImp(AliRsnCutPIDITS)
index 2bda631..689e0ec 100644 (file)
 #include "AliPID.h"
 
 #include "AliESDtrack.h"
-#include "AliESDtrackCuts.h"
 #include "AliESDpid.h"
-
 #include "AliAODpidUtil.h"
 
-#include "AliRsnDaughter.h"
 #include "AliRsnCut.h"
 
+class AliESDtrackCuts;
+class AliAODpidUtil;
+class AliRsnDaughter;
+
 class AliRsnCutPIDITS : public AliRsnCut {
 public:
 
@@ -46,8 +47,8 @@ public:
    void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
    void             SetRefType(EPARTYPE type)                     {fRefType = type;}
 
-   Bool_t           IsTPC(AliVTrack *vtrack);
-   Bool_t           IsSA(AliVTrack *vtrack);
+   Bool_t           IsTPC(const AliVTrack *vtrack);
+   Bool_t           IsSA(const AliVTrack *vtrack);
    virtual Bool_t   IsSelected(TObject *object);
    virtual void     Print(const Option_t *option = "") const;
 
@@ -64,7 +65,7 @@ private:
    ClassDef(AliRsnCutPIDITS, 1)
 };
 
-inline Bool_t AliRsnCutPIDITS::IsTPC(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDITS::IsTPC(const AliVTrack *vtrack)
 {
 //
 // Checks if the track has the status flags required for a global track
@@ -80,7 +81,7 @@ inline Bool_t AliRsnCutPIDITS::IsTPC(AliVTrack *vtrack)
    return (isTPCin);
 }
 
-inline Bool_t AliRsnCutPIDITS::IsSA(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDITS::IsSA(const AliVTrack *vtrack)
 {
 //
 // Checks if the track has the status flags required for an ITS standalone track
index 00e07e8..f6852f1 100644 (file)
@@ -2,7 +2,9 @@
 #define ALIRSNCUTPIDNSIGMA_H
 
 //
-// Class for generalized n-sigma PID cuts with detectors
+// Class for generalized n-sigma PID cuts with detectors.
+// Allows to choose the detector to check and define a momentum range
+// in order to permit different cuts in different ranges.
 //
 
 #include "AliPID.h"
@@ -32,9 +34,9 @@ public:
    void             SetNSigmaRange(Double_t min, Double_t max)    {AliRsnCut::SetRangeD(min, max);}
    void             SetSpecies(AliPID::EParticleType type)        {fSpecies = type;}
    
-   Bool_t           IsITS(AliVTrack *vtrack);
-   Bool_t           IsTPC(AliVTrack *vtrack);
-   Bool_t           IsTOF(AliVTrack *vtrack);
+   Bool_t           IsITS(const AliVTrack *vtrack) const;
+   Bool_t           IsTPC(const AliVTrack *vtrack) const;
+   Bool_t           IsTOF(const AliVTrack *vtrack) const;
    
    virtual Bool_t   IsSelected(TObject *object);
    virtual void     Print(const Option_t *option = "") const;
@@ -50,7 +52,7 @@ private:
    ClassDef(AliRsnCutPIDNSigma, 1)
 };
 
-inline Bool_t AliRsnCutPIDNSigma::IsITS(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDNSigma::IsITS(const AliVTrack *vtrack) const
 {
 //
 // Checks if the track has the status flags required for an ITS standalone track
@@ -62,7 +64,7 @@ inline Bool_t AliRsnCutPIDNSigma::IsITS(AliVTrack *vtrack)
    return kTRUE;
 }
 
-inline Bool_t AliRsnCutPIDNSigma::IsTPC(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDNSigma::IsTPC(const AliVTrack *vtrack) const
 {
 //
 // Checks if the track has the status flags required for a TPC track
@@ -73,7 +75,7 @@ inline Bool_t AliRsnCutPIDNSigma::IsTPC(AliVTrack *vtrack)
    return kTRUE;
 }
 
-inline Bool_t AliRsnCutPIDNSigma::IsTOF(AliVTrack *vtrack)
+inline Bool_t AliRsnCutPIDNSigma::IsTOF(const AliVTrack *vtrack) const
 {
 //
 // Checks if the track has the status flags required for an ITS standalone track
index a0ecf3f..fbf8b6d 100644 (file)
@@ -16,6 +16,7 @@
 //          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
+#include "AliPID.h"
 #include "AliAnalysisManager.h"
 #include "AliESDInputHandler.h"
 #include "AliESDpid.h"
index 395cd8f..cce4d7b 100644 (file)
 #ifndef ALIRSNCUTPIDTPC_H
 #define ALIRSNCUTPIDTPC_H
 
-#include "AliPID.h"
-
 #include "AliRsnCut.h"
 
+class AliPID;
 class AliESDpid;
 class AliAODpidUtil;
 
@@ -40,7 +39,7 @@ public:
    void             SetMomentumRange(Double_t min, Double_t max)  {fMomMin = min; fMomMax = max;}
    void             SetNSigmaRange(Double_t min, Double_t max)    {fMinD = min; fMaxD = max;}
    void             SetRefType(EPARTYPE type)                     {fRefType = type;}
-   void             SetBBParam(Double_t *p)                       {SetBBParam(p[0], p[1], p[2], p[3], p[4]);}
+   void             SetBBParam(const Double_t *p)                 {SetBBParam(p[0], p[1], p[2], p[3], p[4]);}
    void             SetBBParam(Double_t p0, Double_t p1, Double_t p2, Double_t p3, Double_t p4);
 
    virtual Bool_t   IsSelected(TObject *object);
index 1294720..f3a2c42 100644 (file)
@@ -46,7 +46,6 @@ inline Bool_t AliRsnCutPrimaryVertex::CheckVertex(AliVVertex *vertex)
 
    if (!vertex) return kFALSE; 
    if (vertex->GetNContributors() < 1) return kFALSE;
-   
    return kTRUE;
 }
 
index 433f76b..a3bddd1 100644 (file)
@@ -10,6 +10,7 @@
 #include "AliLog.h"
 
 #include "AliRsnExpression.h"
+#include "AliRsnCut.h"
 
 #include "AliRsnCutSet.h"
 
@@ -284,7 +285,7 @@ Bool_t AliRsnCutSet::IsValidScheme()
 }
 
 //_____________________________________________________________________________
-TString AliRsnCutSet::ShowCutScheme()
+TString AliRsnCutSet::ShowCutScheme() const
 {
 //
 // Utility method to check validity of expression
index dd216f3..6ca9c70 100644 (file)
@@ -16,8 +16,8 @@
 #include <TObjArray.h>
 
 #include "AliRsnTarget.h"
-#include "AliRsnCut.h"
 
+class AliRsnCut;
 class AliRsnDaughter;
 class AliRsnExpression;
 class AliRsnPairParticle;
@@ -38,7 +38,7 @@ public:
    Int_t     GetIndexByCutName(TString s);
    Bool_t    Passed();
    Bool_t    IsValidScheme();
-   TString   ShowCutScheme();
+   TString   ShowCutScheme() const;
    Int_t     TestExpression(TString opt = "short");
    void      PrintSetInfo();
 
index 317eb86..3547cd9 100644 (file)
@@ -97,7 +97,7 @@ inline const char * AliRsnCutTrackQuality::Binary(UInt_t number)
 
     UInt_t z;
     for (z = 512; z > 0; z >>= 1)
-      strncat(b, ((number & z) == z) ? "1" : "0",1);
+        strcat(b, ((number & z) == z) ? "1" : "0");
 
     return b;
 }
diff --git a/PWG2/RESONANCES/AliRsnCutTrue.cxx b/PWG2/RESONANCES/AliRsnCutTrue.cxx
new file mode 100644 (file)
index 0000000..ba5fb5d
--- /dev/null
@@ -0,0 +1,78 @@
+//
+// This cut selects the AliRsnDaughter objects pointing
+// to tracks with a well defined true particle species,
+// defined through its PDG code or species according the
+// enumeration defined in AliRsnDaughter class.
+// ---
+// Using this cut on data results in no tracks passing it.
+//
+
+#include "AliRsnCutTrue.h"
+
+ClassImp(AliRsnCutTrue)
+
+//__________________________________________________________________________________________________
+AliRsnCutTrue::AliRsnCutTrue(const char *name, Int_t pdg) :
+   AliRsnCut(name, AliRsnTarget::kDaughter, pdg)
+{
+//
+// Constructor version #1:
+// pass directly the PDG code
+//
+}
+
+//__________________________________________________________________________________________________
+AliRsnCutTrue::AliRsnCutTrue(const char *name, AliRsnDaughter::ESpecies species) :
+   AliRsnCut(name, AliRsnTarget::kDaughter, AliRsnDaughter::SpeciesPDG(species))
+{
+//
+// Constructor version #2:
+// pass the species from AliRsnDaughter enum, which is converted into PDG code
+//
+}
+
+//__________________________________________________________________________________________________
+AliRsnCutTrue::AliRsnCutTrue(const AliRsnCutTrue &copy) :
+   AliRsnCut(copy)
+{
+//
+// Copy constructor
+//
+}
+
+//__________________________________________________________________________________________________
+AliRsnCutTrue& AliRsnCutTrue::operator=(const AliRsnCutTrue &copy)
+{
+//
+// Assignment operator
+//
+
+   AliRsnCut::operator=(copy);
+   return (*this);
+}
+
+//__________________________________________________________________________________________________
+Bool_t AliRsnCutTrue::IsSelected(TObject *obj)
+{
+//
+// Check:
+// if the MC reference is present, recover PDG
+// and check if it matches the required one, in absolute value.
+//
+
+   // convert target
+   if (!TargetOK(obj)) return kFALSE;
+   
+   // check if MC is present
+   if (!fDaughter->GetRefMC()) {
+      AliError("Cannot check cut 'AliRsnCutTrue' without MC information");
+      return kFALSE;
+   }
+   
+   // compare PDG
+   fCutValueI = fDaughter->GetPDGAbs();
+   return OkValueI();
+}
+
+   
+   
diff --git a/PWG2/RESONANCES/AliRsnCutTrue.h b/PWG2/RESONANCES/AliRsnCutTrue.h
new file mode 100644 (file)
index 0000000..8577e5f
--- /dev/null
@@ -0,0 +1,34 @@
+#ifndef ALIRSNCUTTRUE_H
+#define ALIRSNCUTTRUE_H
+
+//
+// This cut selects the AliRsnDaughter objects pointing
+// to tracks with a well defined true particle species,
+// defined through its PDG code or species according the
+// enumeration defined in AliRsnDaughter class.
+// ---
+// Using this cut on data results in no tracks passing it.
+//
+
+#include "AliRsnDaughter.h"
+#include "AliRsnCut.h"
+
+class AliRsnCutTrue : public AliRsnCut {
+   
+public:
+
+   AliRsnCutTrue(const char *name, Int_t pdg);
+   AliRsnCutTrue(const char *name, AliRsnDaughter::ESpecies species);
+   AliRsnCutTrue(const AliRsnCutTrue& copy);
+   AliRsnCutTrue& operator=(const AliRsnCutTrue &copy);
+   virtual ~AliRsnCutTrue() { }
+   
+   virtual Bool_t IsSelected(TObject *obj);
+   
+private:
+
+   ClassDef(AliRsnCutTrue,1)    // AliRsnCutTrue class
+
+};
+
+#endif
index 2be46a0..5fe68c1 100644 (file)
@@ -15,6 +15,7 @@
 // author: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
 
+#include "AliRsnValue.h"
 #include "AliRsnDaughter.h"
 #include "AliRsnMother.h"
 #include "AliRsnEvent.h"
index 4d3c91c..dae7712 100644 (file)
@@ -19,7 +19,8 @@
 #define ALIRSNCUTVALUE_H
 
 #include "AliRsnCut.h"
-#include "AliRsnValue.h"
+
+class AliRsnValue;
 
 class AliRsnCutValue : public AliRsnCut {
 public:
@@ -39,7 +40,7 @@ public:
 
 protected:
 
-   AliRsnValue *fValue;
+   AliRsnValue *fValue;   // value object used for cuts
 
    ClassDef(AliRsnCutValue, 1)
 };
index cd17ec3..c68e377 100644 (file)
@@ -2,7 +2,9 @@
 #define ALIRSNDAUGHTER_H
 
 //
-//  Interface to single daughter candidate.
+// Interface to single daughter candidate.
+// Used for old-version analysis and for
+// selecting tracks in mini package
 //
 
 #include <TMath.h>
index fe3651e..0a4e62a 100644 (file)
@@ -48,11 +48,11 @@ public:
    void SetRefType(AliRsnDaughter::ERefType type) {fRefType = type;}
    
    Bool_t MatchesPID(AliRsnDaughter *daughter);
-   Bool_t MatchesCharge(AliRsnDaughter *daughter);
-   Bool_t MatchesRefType(AliRsnDaughter *daughter);
+   Bool_t MatchesCharge(AliRsnDaughter *daughter)  const;
+   Bool_t MatchesRefType(AliRsnDaughter *daughter) const;
    Bool_t MatchesPDG(Int_t pdgCode)                  {return (AliRsnDaughter::SpeciesPDG(fPID) == pdgCode);}
-   Bool_t MatchesChargeS(Short_t charge)             {return (GetChargeS() == charge);}
-   Bool_t MatchesChargeC(Char_t charge)              {return (GetChargeC() == charge);}
+   Bool_t MatchesChargeS(Short_t charge) const       {return (GetChargeS() == charge);}
+   Bool_t MatchesChargeC(Char_t charge)  const       {return (GetChargeC() == charge);}
 
 private:
 
@@ -89,7 +89,7 @@ inline Bool_t AliRsnDaughterDef::MatchesPID(AliRsnDaughter *daughter)
 }
  
 //__________________________________________________________________________________________________
-inline Bool_t AliRsnDaughterDef::MatchesCharge(AliRsnDaughter *daughter)
+inline Bool_t AliRsnDaughterDef::MatchesCharge(AliRsnDaughter *daughter) const
 {
 //
 // Checks if the passed daughter charge matches that defined in fCharge data member.
@@ -106,7 +106,7 @@ inline Bool_t AliRsnDaughterDef::MatchesCharge(AliRsnDaughter *daughter)
 }
 
 //__________________________________________________________________________________________________
-inline Bool_t AliRsnDaughterDef::MatchesRefType(AliRsnDaughter *daughter)
+inline Bool_t AliRsnDaughterDef::MatchesRefType(AliRsnDaughter *daughter) const
 {
 //
 // Checks that the daughter object type matches that defined in fRefType data member.
index 15c08d2..ce6c626 100644 (file)
@@ -2,7 +2,7 @@
 #include <TEntryList.h>
 
 #include "AliLog.h"
-//#include "AliRsnMiniParticle.h"
+
 #include "AliRsnCutSet.h"
 #include "AliRsnDaughterDef.h"
 
@@ -288,58 +288,3 @@ void AliRsnDaughterSelector::ScanEvent(AliRsnEvent* ev)
    
    //Print();
 }
-
-/*
-//__________________________________________________________________________________________________
-AliRsnMiniEvent AliRsnDaughterSelector::CreateMiniEvent(AliRsnEvent* ev)
-{
-//
-// Loop over event and fill all entry lists
-//
-
-   AliRsnMiniEvent newEv;
-   AliRsnMiniParticle newPart;
-
-   Int_t id, is;
-   Int_t nSel, nTot = ev->GetAbsoluteSum();
-   AliRsnDaughter check;
-   TClonesArray *cutsArray = 0x0, *entryArray = 0x0;
-   
-   for (id = 0; id < nTot; id++) {
-      ev->SetDaughter(check, id);
-      // some checks
-      if (!check.GetRef()) {
-         AliDebugClass(1, Form("[%s]: daughter has NULL ref", GetName()));
-         continue;
-      }
-      if (!check.IsOK()) {
-         AliDebugClass(1, Form("[%s]: daughter is BAD", GetName()));
-         continue;
-      }
-      // copy informations
-      if (check.GetRefMC()) {
-         newPart.PsimX() = check.GetRefMC()->Px();
-         newPart.PsimY() = check.GetRefMC()->Py();
-         newPart.PsimZ() = check.GetRefMC()->Pz();
-      }
-      newPart.PrecX() = check.GetRef()->Px();
-      newPart.PrecY() = check.GetRef()->Py();
-      newPart.PrecZ() = check.GetRef()->Pz();
-      newPart.Charge() = check.GetRef()->Charge();
-      newPart.Mother() = check.GetMother();
-      newPart.MotherPDG() = check.GetMotherPDG();
-      newPart.CutBits() = 0x0;
-      // check with all cuts in that charge
-      nSel = cutsArray->GetEntries();
-      for (is = 0; is < nSel; is++) {
-         AliRsnCutSet *cuts = (AliRsnCutSet*)cutsArray->At(is);
-         if (cuts->IsSelected(&check)) newPart.SetCutBit(is);
-      }
-      // add only if it satisfied a cut bit
-      if (newPart.CutBits() != 0) newEv.AddParticle(newPart);
-   }
-   
-   return newEv;
-   //Print();
-}
-*/
index 627966e..e8cc8ad 100644 (file)
@@ -4,8 +4,6 @@
 #include <TNamed.h>
 #include <TClonesArray.h>
 
-//#include "AliRsnMiniEvent.h"
-
 class TEntryList;
 
 class AliRsnCutSet;
@@ -27,7 +25,6 @@ public:
    TEntryList*   GetSelected(Int_t i, Char_t charge);
    TEntryList*   GetSelected(Int_t i, Short_t charge);
    void          ScanEvent(AliRsnEvent *ev);
-   //AliRsnMiniEvent CreateMiniEvent(AliRsnEvent *ev);
    
    virtual void  Print(Option_t* option = "") const;
 
index 6e2a700..845c018 100644 (file)
@@ -42,7 +42,8 @@ AliRsnEvent::AliRsnEvent(AliVEvent *ref, AliVEvent *refMC) :
    fRef(ref),
    fRefMC(refMC),
    fLeading(-1),
-   fPID(0x0)
+   fPID(0x0),
+   fAODList(0x0)
 {
 //
 // Default constructor.
@@ -55,7 +56,8 @@ AliRsnEvent::AliRsnEvent(const AliRsnEvent &event) :
    fRef(event.fRef),
    fRefMC(event.fRefMC),
    fLeading(event.fLeading),
-   fPID(event.fPID)
+   fPID(event.fPID),
+   fAODList(event.fAODList)
 {
 //
 // Copy constructor.
@@ -74,6 +76,7 @@ AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent & event)
    fRefMC           = event.fRefMC;
    fLeading         = event.fLeading;
    fPID             = event.fPID;
+   fAODList         = event.fAODList;
 
    return (*this);
 }
index 834e537..5daa2bd 100644 (file)
@@ -10,6 +10,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+#include <TClonesArray.h>
+
 #include "AliLog.h"
 
 #include "AliStack.h"
@@ -17,6 +19,7 @@
 #include "AliMCEvent.h"
 #include "AliESDEvent.h"
 #include "AliAODEvent.h"
+#include "AliAODMCParticle.h"
 
 #include "AliRsnDaughter.h"
 
@@ -33,7 +36,7 @@ public:
 
    // basic setters/getters
    void             SetRef(AliVEvent *ref)              {fRef = ref;}
-   void             SetRefMC(AliVEvent *refmc)          {fRefMC = refmc;}
+   void             SetRefMC(AliVEvent *refmc);
    void             SetPIDResponse(AliPIDResponse *pid) {fPID = pid;}
    AliVEvent*       GetRef()                            {return fRef;}
    AliVEvent*       GetRefMC()                          {return fRefMC;}
@@ -49,6 +52,8 @@ public:
    AliMCEvent*      GetRefMCESD()                     {if (IsESD()) return (AliMCEvent *)fRefMC; return 0x0;}
    AliAODEvent*     GetRefAOD()                       {if (IsAOD()) return (AliAODEvent*)fRef;   return 0x0;}
    AliAODEvent*     GetRefMCAOD()                     {if (IsAOD()) return (AliAODEvent*)fRefMC; return 0x0;}
+   TClonesArray*    GetAODList()                      {return fAODList;}
+   Bool_t           HasMC()                           {if (IsESD()) return (fRefMC != 0x0); else if (IsAOD()) return (fRefMC != 0x0 && fAODList != 0x0); return kFALSE;}
 
    // setters for a daughter
    void             SetDaughter          (AliRsnDaughter &daughter, Int_t index, Bool_t fromMC = kFALSE);
@@ -79,8 +84,9 @@ private:
    AliVEvent      *fRefMC;          //  pointer to reference MC event (if any)
    Int_t           fLeading;        //  index of leading track
    AliPIDResponse *fPID;            //  pointer to PID response
+   TClonesArray   *fAODList;        //  pointer to AOD list of particles (if any)
 
-   ClassDef(AliRsnEvent, 5);
+   ClassDef(AliRsnEvent, 6);
 };
 
 inline Bool_t AliRsnEvent::InputOK()
@@ -101,4 +107,25 @@ inline Bool_t AliRsnEvent::InputOK()
    }
 }
 
+inline void AliRsnEvent::SetRefMC(AliVEvent *mc) 
+{
+//
+// Assign pointer to MC event.
+// If it is an AOD, retrieve the list of MC particles
+//
+
+   if (!mc) {
+      fRefMC = 0x0;
+      fAODList = 0x0;
+   }
+
+   fRefMC = mc;
+   fAODList = 0x0;
+   if (fRefMC->InheritsFrom(AliAODEvent::Class())) {
+      AliAODEvent *aod = (AliAODEvent*)mc;
+      fAODList = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+      if (!fAODList) fRefMC = 0x0;
+   }
+}
+
 #endif
index 071d0f2..7d729c8 100644 (file)
@@ -1,3 +1,12 @@
+//
+// Class AliRsnInputHandler
+//
+// AliRsnInputHandler
+// TODO example
+// author:
+//        Martin Vala (martin.vala@cern.ch)
+//
+
 #include <Riostream.h>
 #include "AliLog.h"
 
@@ -6,6 +15,7 @@
 #include "AliMixInputEventHandler.h"
 #include "AliMCEventHandler.h"
 
+#include "AliRsnCutSet.h"
 #include "AliRsnInputHandler.h"
 ClassImp(AliRsnInputHandler)
 
@@ -13,7 +23,22 @@ ClassImp(AliRsnInputHandler)
 AliRsnInputHandler::AliRsnInputHandler(const char *name) :
    AliInputEventHandler(name, name),
    fRsnEvent(0),
-   fRsnSelector()
+   fRsnSelector(),
+   fRsnEventCuts(0)
+{
+//
+// Default constructor.
+//
+   AliDebug(AliLog::kDebug + 10, "<-");
+   AliDebug(AliLog::kDebug + 10, "->");
+}
+
+//_____________________________________________________________________________
+AliRsnInputHandler::AliRsnInputHandler(const AliRsnInputHandler &copy) :
+   AliInputEventHandler(),
+   fRsnEvent(0),
+   fRsnSelector(),
+   fRsnEventCuts(copy.fRsnEventCuts)
 {
 //
 // Default constructor.
@@ -23,6 +48,17 @@ AliRsnInputHandler::AliRsnInputHandler(const char *name) :
 }
 
 //_____________________________________________________________________________
+AliRsnInputHandler& AliRsnInputHandler::operator=(const AliRsnInputHandler &copy)
+{
+//
+// Default constructor.
+//
+   fRsnEventCuts = copy.fRsnEventCuts;
+   return *this;
+}
+
+
+//_____________________________________________________________________________
 AliRsnInputHandler::~AliRsnInputHandler()
 {
 //
@@ -108,6 +144,9 @@ Bool_t AliRsnInputHandler::BeginEvent(Long64_t entry)
 
             //fRsnPIDManager.ApplyCuts(fRsnEvent);
             fRsnSelector.Reset();
+            
+            // reject event if needed
+            if (fRsnEventCuts) if (!fRsnEventCuts->IsSelected(fRsnEvent)) return kTRUE;
             fRsnSelector.ScanEvent(fRsnEvent);
          }
       }
index 21d358b..6a848d6 100644 (file)
 #include "AliRsnDaughterSelector.h"
 
 class AliRsnEvent;
+class AliRsnCutSet;
 class AliRsnInputHandler : public AliInputEventHandler {
 
 public:
    AliRsnInputHandler(const char *name = "rsnInputHandler");
+   AliRsnInputHandler(const AliRsnInputHandler& handler);
+   AliRsnInputHandler &operator=(const AliRsnInputHandler &handler);
    virtual ~AliRsnInputHandler();
 
    // From the interface
@@ -30,18 +33,16 @@ public:
    virtual Bool_t  Notify(const char *path);
    virtual Bool_t  GetEntry();
 
+   void SetEventCuts(AliRsnCutSet *cuts) {fRsnEventCuts = cuts;}
    AliRsnEvent *GetRsnEvent() { return fRsnEvent; }
    //AliRsnPIDManager *GetPIDManager() { return &fRsnPIDManager; }
    AliRsnDaughterSelector *GetSelector() { return &fRsnSelector; }
 
 private:
 
-   AliRsnEvent *fRsnEvent; //!
-   //AliRsnPIDManager fRsnPIDManager;
-   AliRsnDaughterSelector fRsnSelector;
-
-   AliRsnInputHandler(const AliRsnInputHandler& handler);
-   AliRsnInputHandler &operator=(const AliRsnInputHandler &handler);
+   AliRsnEvent *fRsnEvent;               //! pointer to current event
+   AliRsnDaughterSelector fRsnSelector;  //  pointer to selector for building lists
+   AliRsnCutSet *fRsnEventCuts;          //  unique set of cuts to be used for whole analysis
 
    ClassDef(AliRsnInputHandler, 1)
 };
index f774609..5c8e620 100644 (file)
@@ -22,6 +22,7 @@
 #include <Riostream.h>
 
 #include "AliLog.h"
+#include "AliCFContainer.h"
 
 #include "AliRsnValue.h"
 #include "AliRsnLoop.h"
index 7ad84bb..361b1ac 100644 (file)
@@ -2,7 +2,24 @@
 #define ALIRSNLISTOUTPUT_H
 
 //
-// General class for outputs which can stay into a TList
+// Class AliRsnListOutput
+//
+// This class defines a base classe to implement a Output
+// which uses the internal RSN package event format (AliRsnEvent).
+// It contains some default flags which turn out to be useful:
+//  - a flag to select only the "true" pairs (tracks from same resonance)
+//  - a flag to know if the computation is done over two events (mixing)
+//
+// Any kind of analysis object should be implemented as inheriting from this
+// because the AliRsnAnalyzer which executes the analysis will accept a collection
+// of such objects, in order to have a unique format of processing method
+//
+// The user who implements a kind of computation type should inherit from
+// this class and override the virtual Outputs defined in it, which
+// initialize the final output histogram and define how to process data.
+//
+//
+// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
 //
 
 #include <TRef.h>
@@ -16,8 +33,7 @@
 #include <TNtuple.h>
 #include <THnSparse.h>
 
-#include "AliCFContainer.h"
-
+class AliCFContainer;
 class AliRsnValue;
 
 class AliRsnListOutput : public TNamed {
@@ -35,12 +51,12 @@ public:
    const AliRsnListOutput& operator=(const AliRsnListOutput &copy);
    virtual ~AliRsnListOutput();
 
-   EOut            GetType()               {return  fType;}
-   Int_t           GetSteps()              {return  fSteps;}
+   EOut            GetType() const         {return  fType;}
+   Int_t           GetSteps() const        {return  fSteps;}
    TObjArray*      GetValues()             {return &fValues;}
    Int_t           GetNValues()            {return (fNValues = fValues.GetEntries());}
-   AliRsnValue*    GetValue(Int_t i)       {return (AliRsnValue*)fValues[i];}
-   Int_t           GetIndex()              {return  fIndex;}
+   AliRsnValue*    GetValue(Int_t i) const {return (AliRsnValue*)fValues[i];}
+   Int_t           GetIndex() const        {return  fIndex;}
    void            SetType(EOut type)      {fType = type;}
    void            SetSteps(Int_t n)       {fSteps = n;}
    void            SetSkipFailed(Bool_t y) {fSkipFailed = y;}
index 50f311d..704d488 100644 (file)
@@ -2,7 +2,11 @@
 #define ALIRSNLOOP_H
 
 //
-// Base class object for all computation devices.
+// Base class to implement any computation within the RSN package.
+// It contains only an array of output objects which must derive 
+// from AliRsnOutput.
+// Its core functions ar Init() and DoLoop() which must be 
+// overloaded by any class which inherits from this.
 //
 
 #include "TNamed.h"
@@ -28,7 +32,7 @@ public:
 
    AliRsnLoop(const char *name = "default", Bool_t isMixed = kFALSE);
    AliRsnLoop(const AliRsnLoop &copy);
-   AliRsnLoop& operator=(const AliRsnLoop&);
+   AliRsnLoop& operator=(const AliRsnLoop &copy);
    ~AliRsnLoop();
    
    void           SetMixed(Bool_t yn = kTRUE)     {fIsMixed = yn;}
index 76fd524..7ea5ae5 100644 (file)
@@ -3,8 +3,10 @@
 // Implements a simple loop on tracks from one of the entry lists
 // filled by the task AliRsnInputHandler, adding a check on their
 // definition specified in the daughter def.
+// Author: A. Pulvirenti
 //
 
+#include <Riostream.h>
 #include <TEntryList.h>
 
 #include "AliLog.h"
@@ -20,6 +22,7 @@ ClassImp(AliRsnLoopDaughter)
 //_____________________________________________________________________________
 AliRsnLoopDaughter::AliRsnLoopDaughter(const char *name, Int_t listID, AliRsnDaughterDef *def) :
    AliRsnLoop(name),
+   fTrueMC(kFALSE),
    fOnlyTrue(kFALSE),
    fListID(listID),
    fDef(def),
@@ -33,6 +36,7 @@ AliRsnLoopDaughter::AliRsnLoopDaughter(const char *name, Int_t listID, AliRsnDau
 //_____________________________________________________________________________
 AliRsnLoopDaughter::AliRsnLoopDaughter(const AliRsnLoopDaughter& copy) :
    AliRsnLoop(copy),
+   fTrueMC(copy.fTrueMC),
    fOnlyTrue(copy.fOnlyTrue),
    fListID(copy.fListID),
    fDef(copy.fDef),
@@ -51,6 +55,7 @@ AliRsnLoopDaughter& AliRsnLoopDaughter::operator=(const AliRsnLoopDaughter& copy
 //
 
    AliRsnLoop::operator=(copy);
+   fTrueMC = copy.fTrueMC;
    fOnlyTrue = copy.fOnlyTrue;
    fListID = copy.fListID;
    fDaughter = copy.fDaughter;
@@ -117,6 +122,9 @@ Int_t AliRsnLoopDaughter::DoLoop
       }
    }
    
+   // if it is required to loop over True MC, do this here and skip the rest of the method
+   if (fTrueMC) return LoopTrueMC(evMain);
+   
    TObjArrayIter next(&fOutputs);
    AliRsnListOutput *out = 0x0;
    
@@ -131,6 +139,7 @@ Int_t AliRsnLoopDaughter::DoLoop
          if (fOnlyTrue && !fDef->MatchesPID(&fDaughter)) continue;
          if (!fDef->MatchesCharge(&fDaughter)) continue;
          if (!fDef->MatchesRefType(&fDaughter)) continue;
+         fDaughter.FillP(fDef->GetMass());
          // fill outputs
          nadd++;
          next.Reset();
@@ -142,3 +151,77 @@ Int_t AliRsnLoopDaughter::DoLoop
    
    return nadd;
 }
+
+//_____________________________________________________________________________
+Int_t AliRsnLoopDaughter::LoopTrueMC(AliRsnEvent *rsn)
+{
+//
+// Loop on event and fill containers
+//
+
+   // check presence of MC reference
+   if (!rsn->GetRefMC()) {
+      AliError("Need a MC to compute efficiency");
+      return 0;
+   }
+   
+   // check event type:
+   // must be ESD or AOD, and then use a bool to know in the rest
+   if (!rsn->IsESD() && !rsn->IsAOD()) {
+      AliError("Need to process ESD or AOD input");
+      return 0;
+   }
+   
+   // retrieve the MC primary vertex position
+   // and do some additional coherence checks
+   Int_t npart = 0;
+   TClonesArray *listAOD = 0x0;
+   if (rsn->IsESD()) {
+      npart = rsn->GetRefMCESD()->GetNumberOfTracks();
+   } else {
+      AliAODEvent *aod = rsn->GetRefMCAOD();
+      listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+      if (listAOD) npart = listAOD->GetEntries();
+   }
+   
+   // check number of particles
+   if (!npart) {
+      AliInfo("Empty event");
+      return 0;
+   }
+   
+   // utility variables
+   Int_t ipart, count = 0;
+   TObjArrayIter next(&fOutputs);
+   AliRsnListOutput *out = 0x0;
+   Int_t pdg = AliRsnDaughter::SpeciesPDG(fDef->GetPID());
+   
+   
+   // loop over particles
+   for (ipart = 0; ipart < npart; ipart++) {
+      // check i-th particle
+      if (rsn->IsESD()) {
+         if (!rsn->GetRefMCESD()->Stack()->IsPhysicalPrimary(ipart)) continue;
+         AliMCParticle *part = (AliMCParticle*)rsn->GetRefMCESD()->GetTrack(ipart);
+         if (TMath::Abs(part->Particle()->GetPdgCode()) != pdg) continue;
+         fDaughter.SetRef  (rsn->GetRefMCESD()->GetTrack(ipart));
+         fDaughter.SetRefMC(rsn->GetRefMCESD()->GetTrack(ipart));
+      } else {
+         AliAODMCParticle *part = (AliAODMCParticle*)listAOD->At(ipart);
+         if (!part->IsPhysicalPrimary()) continue;
+         if (TMath::Abs(part->GetPdgCode()) != pdg) continue;
+         fDaughter.SetRef  ((AliAODMCParticle*)listAOD->At(ipart));
+         fDaughter.SetRefMC((AliAODMCParticle*)listAOD->At(ipart));
+      }
+      //if (fDaughter.GetPDG() != AliRsnDaughter::SpeciesPDG(fDef->GetPID())) continue;
+      fDaughter.FillP(fDef->GetMass());
+      // fill outputs
+      count++;
+      next.Reset();
+      while ( (out = (AliRsnListOutput*)next()) ) {
+         out->Fill(&fDaughter);
+      }
+   }
+   
+   return count;
+}
index d329881..94b09d0 100644 (file)
@@ -2,7 +2,10 @@
 #define ALIRSNLOOPDAUGHTER_H
 
 //
-// Class for computations on single daughters
+// Computator for single daughters.
+// Implements a simple loop on tracks from one of the entry lists
+// filled by the task AliRsnInputHandler, adding a check on their
+// definition specified in the daughter def.
 //
 
 #include "AliRsnDaughter.h"
@@ -15,13 +18,14 @@ public:
 
    AliRsnLoopDaughter(const char *name = "default", Int_t listID = 0, AliRsnDaughterDef *def = 0);
    AliRsnLoopDaughter(const AliRsnLoopDaughter &copy);
-   AliRsnLoopDaughter& operator=(const AliRsnLoopDaughter&);
+   AliRsnLoopDaughter& operator=(const AliRsnLoopDaughter &copy);
    ~AliRsnLoopDaughter();
    
-   Int_t              GetListID()                    {return  fListID;}
+   Int_t              GetListID() const              {return  fListID;}
    AliRsnDaughterDef* GetDef()                       {return  fDef;}
    AliRsnDaughter*    GetDaughter()                  {return &fDaughter;}
-                                                     
+
+   void               SetTrueMC(Bool_t yn = kTRUE)   {fTrueMC = yn;}
    void               SetOnlyTrue(Bool_t yn = kTRUE) {fOnlyTrue = yn;}
    void               SetListID(Int_t i)             {fListID = i;}
    void               SetDef(AliRsnDaughterDef *def) {fDef = def;}
@@ -32,6 +36,9 @@ public:
 
 protected:
 
+   Int_t LoopTrueMC(AliRsnEvent *rsn);
+
+   Bool_t             fTrueMC;     //  if this flag is TRUE, scan the MC for all true resonances from MC
    Bool_t             fOnlyTrue;   //  for selecting only true particles
    Int_t              fListID;     //  index of entry list to use
    AliRsnDaughterDef *fDef;        //  definition for selection
index d33d5ed..59ad7b2 100644 (file)
@@ -51,6 +51,10 @@ AliRsnLoopEff::AliRsnLoopEff(const AliRsnLoopEff& copy) :
 //_____________________________________________________________________________
 AliRsnLoopEff& AliRsnLoopEff::operator=(const AliRsnLoopEff& copy)
 {
+//
+// Assignment operator
+//
+
    AliRsnLoop::operator=(copy);
 
    fAddSteps = copy.fAddSteps;
@@ -121,7 +125,7 @@ Bool_t AliRsnLoopEff::Init(const char *prefix, TList *list)
 }
 
 //_____________________________________________________________________________
-Int_t AliRsnLoopEff::FindTrack(Int_t label, AliVEvent *event)
+Int_t AliRsnLoopEff::FindTrack(Int_t label, const AliVEvent *event)
 {
 //
 // Loops an event and find all tracks which have a label
index 5edac13..61dcefe 100644 (file)
@@ -2,7 +2,9 @@
 #define ALIRSNLOOPEFF_H
 
 //
-// Class to combine pairs of daughters.
+// Class to compute an efficiency.
+// Builds a 2-elements CF container
+// to fill with resonances generated and passing some defined cuts.
 //
 
 #include "AliLog.h"
@@ -15,7 +17,7 @@ public:
 
    AliRsnLoopEff(const char *name = "default", Int_t nSteps = 0, Double_t maxDistPV = 1E-2);
    AliRsnLoopEff(const AliRsnLoopEff &copy);
-   AliRsnLoopEff& operator=(const AliRsnLoopEff&);
+   AliRsnLoopEff& operator=(const AliRsnLoopEff &copy);
    ~AliRsnLoopEff();
 
    AliRsnListOutput* GetOutput()          {return fOutput;}
@@ -27,7 +29,7 @@ public:
 
 protected:
 
-   Int_t             FindTrack(Int_t label, AliVEvent *event);
+   Int_t             FindTrack(Int_t label, const AliVEvent *event);
    Int_t             GetMatchedDaughter(Int_t label, AliRsnEvent *event);
    Double_t          DistanceFromPV(Double_t x, Double_t y, Double_t z);
    Bool_t            CheckDistanceFromPV(Double_t x, Double_t y, Double_t z) {return (DistanceFromPV(x,y,z) <= fMaxDistPV);}
index 5c6dba5..bcf3cd0 100644 (file)
@@ -3,6 +3,7 @@
 //
 // Inherits from basic AliRsnLoopEff for efficiency,
 // and computed efficiencies for single-tracks
+// using cut set definitions.
 //
 // author: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
index 358e7b0..7b5af07 100644 (file)
@@ -158,6 +158,15 @@ Bool_t AliRsnLoopEffPair::AssignMotherAndDaughtersESD(AliRsnEvent *rsnEvent, Int
 //__________________________________________________________________________________________________
 Bool_t AliRsnLoopEffPair::AssignMotherAndDaughtersAOD(AliRsnEvent *rsnEvent, Int_t ipart)
 {
+//
+// Gets a particle in the MC event and try to assign it to the mother.
+// If it has two daughters, retrieve them and assign also them.
+// NOTE: assignment is done only for MC, since reconstructed match is assigned in the same way
+//       for ESD and AOD, if available
+// ---
+// Implementation for AOD inputs
+//
+
    AliAODEvent      *aod     = rsnEvent->GetRefAOD();
    TClonesArray     *listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
    AliAODMCParticle *mother  = (AliAODMCParticle*)listAOD->At(ipart);
index 939fc9f..e49bbe3 100644 (file)
@@ -2,7 +2,8 @@
 // Class AliRsnLoopEffPair
 //
 // Inherits from basic AliRsnAnalysisTaskEff for efficiency,
-// and computed efficiencies for single-tracks
+// and computed efficiencies for pairs
+// using cut sets definition
 //
 // author: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
 //
index 79e2e6c..c774efd 100644 (file)
@@ -1,8 +1,9 @@
 //
-// Computator for single daughters.
-// Implements a simple loop on tracks from one of the entry lists
-// filled by the task AliRsnInputHandler, adding a check on their
-// definition specified in the daughter def.
+// Computator for events.
+// Fills the outputs once per event,
+// using values computed on them,
+// and inheriting the same definitions of outputs
+// as in the mother AliRsnLoop class.
 //
 
 #include "AliLog.h"
index 46d5770..e516f45 100644 (file)
@@ -2,7 +2,9 @@
 #define ALIRSNLOOPEVENT_H
 
 //
-// Class for computations on events
+// Computator for events.
+// The simplest loop, 
+// which is filled once per event.
 //
 
 #include "AliRsnLoop.h"
@@ -12,7 +14,7 @@ public:
 
    AliRsnLoopEvent(const char *name = "default");
    AliRsnLoopEvent(const AliRsnLoopEvent &copy);
-   AliRsnLoopEvent& operator=(const AliRsnLoopEvent&);
+   AliRsnLoopEvent& operator=(const AliRsnLoopEvent &copy);
    ~AliRsnLoopEvent();
    
    virtual void       Print(Option_t *opt = "") const;
index 995a88c..a110647 100644 (file)
@@ -18,6 +18,8 @@
 
 #include "AliLog.h"
 
+#include "AliRsnEvent.h"
+#include "AliRsnPairDef.h"
 #include "AliRsnMother.h"
 #include "AliRsnCutSet.h"
 #include "AliRsnDaughterSelector.h"
@@ -29,8 +31,10 @@ ClassImp(AliRsnLoopPair)
 //_____________________________________________________________________________
 AliRsnLoopPair::AliRsnLoopPair(const char *name, AliRsnPairDef *def, Bool_t isMixed) :
    AliRsnLoop(name, isMixed),
+   fTrueMC(kFALSE),
    fOnlyTrue(kFALSE),
    fCheckDecay(kFALSE),
+   fRangeY(1E20),
    fPairDef(def),
    fPairCuts(0x0),
    fMother()
@@ -46,8 +50,10 @@ AliRsnLoopPair::AliRsnLoopPair(const char *name, AliRsnPairDef *def, Bool_t isMi
 //_____________________________________________________________________________
 AliRsnLoopPair::AliRsnLoopPair(const AliRsnLoopPair& copy) :
    AliRsnLoop(copy),
+   fTrueMC(copy.fTrueMC),
    fOnlyTrue(copy.fOnlyTrue),
    fCheckDecay(copy.fCheckDecay),
+   fRangeY(copy.fRangeY),
    fPairDef(copy.fPairDef),
    fPairCuts(copy.fPairCuts),
    fMother(copy.fMother)
@@ -63,10 +69,16 @@ AliRsnLoopPair::AliRsnLoopPair(const AliRsnLoopPair& copy) :
 //_____________________________________________________________________________
 AliRsnLoopPair& AliRsnLoopPair::operator=(const AliRsnLoopPair& copy)
 {
+//
+// Assignment operator
+//
+
    AliRsnLoop::operator=(copy);
    
+   fTrueMC = copy.fTrueMC;
    fOnlyTrue = copy.fOnlyTrue;
    fCheckDecay = copy.fCheckDecay;
+   fRangeY = copy.fRangeY;
    fPairDef = copy.fPairDef;
    fPairCuts = copy.fPairCuts;
    fMother = copy.fMother;
@@ -126,13 +138,13 @@ Int_t AliRsnLoopPair::DoLoop
 //
 
    if (fIsMixed) {
-      AliDebugClass(1, Form("[%s]: event-mixing loop", GetName()));
+      AliDebugClass(3, Form("[%s]: event-mixing loop", GetName()));
       if (!evMix || !selMix) {
          AliError(Form("[%s] NULL mixed event when mixing is required: cannot process", GetName()));
          return 0;
       }
    } else {
-      AliDebugClass(1, Form("[%s]: single-event loop", GetName()));
+      AliDebugClass(3, Form("[%s]: single-event loop", GetName()));
       evMix = evMain;
       selMix = selMain;
    }
@@ -140,14 +152,17 @@ Int_t AliRsnLoopPair::DoLoop
    
    // check cuts
    if (!OkEvent(evMain)) {
-      AliDebugClass(1, Form("[%s]: main event not accepted", GetName()));
+      AliDebugClass(3, Form("[%s]: main event not accepted", GetName()));
       return 0;
    }
    if (!OkEvent(evMix)) {
-      AliDebugClass(1, Form("[%s]: mixed event not accepted", GetName()));
+      AliDebugClass(3, Form("[%s]: mixed event not accepted", GetName()));
       return 0;
    }
    
+   // if it is required to loop over True MC, do this here and skip the rest of the method
+   if (fTrueMC) return LoopTrueMC(evMain);
+   
    Int_t i0, i1, start, npairs = 0;
    
    TEntryList *list0 = selMain->GetSelected(fListID[0], fPairDef->GetDef1().GetChargeC());
@@ -156,9 +171,9 @@ Int_t AliRsnLoopPair::DoLoop
       AliError("Can't process NULL lists");
       return 0;
    }
-   AliDebugClass(2, Form("[%s]: list counts: %d, %d", GetName(), (Int_t)list0->GetN(), (Int_t)list1->GetN()));
+   AliDebugClass(3, Form("[%s]: list counts: %d, %d", GetName(), (Int_t)list0->GetN(), (Int_t)list1->GetN()));
    if (!list0->GetN() || !list1->GetN()) {
-      AliDebugClass(2, Form("[%s]: at least one list is empty", GetName()));
+      AliDebugClass(3, Form("[%s]: at least one list is empty", GetName()));
       return 0;
    }
    
@@ -178,12 +193,10 @@ Int_t AliRsnLoopPair::DoLoop
          fMother.Sum(1) = fDaughter[0].Psim() + fDaughter[1].Psim();
          fMother.Ref(0).SetXYZM(fMother.Sum(0).X(), fMother.Sum(0).Y(), fMother.Sum(0).Z(), fPairDef->GetMotherMass());
          fMother.Ref(1).SetXYZM(fMother.Sum(1).X(), fMother.Sum(1).Y(), fMother.Sum(1).Z(), fPairDef->GetMotherMass());
-         // check cuts
-         if (fPairCuts) {
-            if (!fPairCuts->IsSelected(&fMother)) {
-               AliDebugClass(2, Form("[%s]: candidate mother didn't pass the cuts", GetName()));
-               continue;
-            }
+         // check rapidity range
+         if (TMath::Abs(fMother.Rapidity(0)) > fRangeY) {
+            AliDebugClass(2, Form("[%s]: Outside rapidity range", GetName()));
+            continue;
          }
          // check mother
          if (fOnlyTrue) {
@@ -192,6 +205,13 @@ Int_t AliRsnLoopPair::DoLoop
                continue;
             }
          }
+         // check cuts
+         if (fPairCuts) {
+            if (!fPairCuts->IsSelected(&fMother)) {
+               AliDebugClass(2, Form("[%s]: candidate mother didn't pass the cuts", GetName()));
+               continue;
+            }
+         }
          // fill outputs
          next.Reset();
          while ( (out = (AliRsnListOutput*)next()) ) {
@@ -216,7 +236,7 @@ Bool_t AliRsnLoopPair::IsTrueMother()
    // daughters have same mother with the right PDG code
    Int_t commonPDG = fMother.CommonMother();
    if (commonPDG != fPairDef->GetMotherPDG()) return kFALSE;
-   AliDebugClass(4, "Found a true mother");
+   AliDebugClass(1, "Found a true mother");
    
    // check #2:
    // checks if daughter have the right particle type
@@ -227,7 +247,259 @@ Bool_t AliRsnLoopPair::IsTrueMother()
       if (!def1.MatchesPID(&fDaughter[0])) return kFALSE;
       if (!def2.MatchesPID(&fDaughter[1])) return kFALSE;
    }
-   AliDebugClass(4, "Decay products match");
+   AliDebugClass(1, "Decay products match");
    
    return kTRUE;
 }
+
+//__________________________________________________________________________________________________
+Bool_t AliRsnLoopPair::AssignMotherAndDaughters(AliRsnEvent *rsnEvent, Int_t ipart)
+{
+//
+// Calls the appropriate assignment method
+//
+
+   // setup pointers
+   fMother.SetDaughter(0, &fDaughter[0]);
+   fMother.SetDaughter(1, &fDaughter[1]);
+   fMother.SetRefEvent(rsnEvent);
+   fDaughter[0].SetOwnerEvent(rsnEvent);
+   fDaughter[1].SetOwnerEvent(rsnEvent);
+
+   if (rsnEvent->IsESD())
+      return AssignMotherAndDaughtersESD(rsnEvent, ipart);
+   else if (rsnEvent->IsAOD())
+      return AssignMotherAndDaughtersAOD(rsnEvent, ipart);
+   else {
+      AliError("Unrecognized input event");
+      return kFALSE;
+   }
+}
+
+//__________________________________________________________________________________________________
+Bool_t AliRsnLoopPair::AssignMotherAndDaughtersESD(AliRsnEvent *rsnEvent, Int_t ipart)
+{
+//
+// Gets a particle in the MC event and try to assign it to the mother.
+// If it has two daughters, retrieve them and assign also them.
+// NOTE: assignment is done only for MC, since reconstructed match is assigned in the same way
+//       for ESD and AOD, if available
+// ---
+// Implementation for ESD inputs
+//
+
+   AliMCEvent    *mc      = rsnEvent->GetRefMCESD();
+   AliStack      *stack   = mc->Stack();
+   AliMCParticle *mother  = (AliMCParticle*)mc->GetTrack(ipart);
+   TParticle     *motherP = mother->Particle();
+   Int_t          ntracks = stack->GetNtrack();
+   
+   // check PDG code and exit if it is wrong
+   if (TMath::Abs(motherP->GetPdgCode()) != fPairDef->GetMotherPDG()) return kFALSE;
+   
+   // check number of daughters and exit if it is not 2
+   if (motherP->GetNDaughters() < 2) return kFALSE;
+   //if (!stack->IsPhysicalPrimary(ipart)) return kFALSE;
+   
+   /*
+   // check distance from primary vertex
+   TLorentzVector vprod;
+   motherP->ProductionVertex(vprod);
+   if (!CheckDistanceFromPV(vprod.X(), vprod.Y(), vprod.Z())) {
+      AliDebugClass(1, "Distant production vertex");
+      return kFALSE;
+   }
+   */
+   
+   // get the daughters and check their PDG code and charge:
+   // if they match one of the pair daughter definitions, 
+   // assign them as MC reference of the 'fDaughter' objects
+   fDaughter[0].Reset();
+   fDaughter[1].Reset();
+   Int_t index[2] = {motherP->GetDaughter(0), motherP->GetDaughter(1)};
+   Int_t i, pdg;
+   Short_t charge;
+   AliMCParticle *daughter = 0x0;
+   for (i = 0; i < 2; i++) {
+      // check index for stack
+      if (index[i] < 0 || index[i] > ntracks) {
+         AliError(Form("Index %d overflow: value = %d, max = %d", i, index[i], ntracks));
+         return kFALSE;
+      }
+      // get daughter and its PDG and charge
+      daughter = (AliMCParticle*)mc->GetTrack(index[i]);
+      pdg      = TMath::Abs(daughter->Particle()->GetPdgCode());
+      charge   = (Short_t)(daughter->Particle()->GetPDG()->Charge() / 3);
+      // check if it matches one definition
+      if (fPairDef->GetDef1().MatchesPDG(pdg) && fPairDef->GetDef1().MatchesChargeS(charge)) {
+         fDaughter[0].SetGood();
+         fDaughter[0].SetRefMC(daughter);
+         fDaughter[0].SetLabel(index[i]);
+      } else if (fPairDef->GetDef2().MatchesPDG(pdg) && fPairDef->GetDef2().MatchesChargeS(charge)) {
+         fDaughter[1].SetGood();
+         fDaughter[1].SetRefMC(daughter);
+         fDaughter[1].SetLabel(index[i]);
+      }
+   }
+   
+   // return success if both daughters were assigned
+   if (fDaughter[0].IsOK() && fDaughter[1].IsOK()) {
+      return kTRUE;
+   } else {
+      fDaughter[0].Reset();
+      fDaughter[1].Reset();
+      return kFALSE;
+   }
+}
+
+//__________________________________________________________________________________________________
+Bool_t AliRsnLoopPair::AssignMotherAndDaughtersAOD(AliRsnEvent *rsnEvent, Int_t ipart)
+{
+//
+// Gets a particle in the MC event and try to assign it to the mother.
+// If it has two daughters, retrieve them and assign also them.
+// NOTE: assignment is done only for MC, since reconstructed match is assigned in the same way
+//       for ESD and AOD, if available
+// ---
+// Implementation for AOD inputs
+//
+
+   AliAODEvent      *aod     = rsnEvent->GetRefAOD();
+   TClonesArray     *listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+   AliAODMCParticle *mother  = (AliAODMCParticle*)listAOD->At(ipart);
+   
+   // check PDG code and exit if it is wrong
+   if (TMath::Abs(mother->GetPdgCode()) != fPairDef->GetMotherPDG()) return kFALSE;
+   
+   // check number of daughters and exit if it is not 2
+   if (mother->GetNDaughters() < 2) return kFALSE;
+   if (!mother->IsPrimary()) return kFALSE;
+   
+   /*
+   // check distance from primary vertex
+   Double_t vprod[3] = {(Double_t)mother->Xv(), (Double_t)mother->Yv(), (Double_t)mother->Zv()};
+   Double_t dv = DistanceFromPV(vprod[0], vprod[1], vprod[2]);
+   if (dv > fMaxDistPV) {
+      AliDebugClass(1, "Distant production vertex");
+      return kFALSE;
+   }
+   */
+   
+   // get the daughters and check their PDG code and charge:
+   // if they match one of the pair daughter definitions, 
+   // assign them as MC reference of the 'fDaughter' objects
+   fDaughter[0].Reset();
+   fDaughter[1].Reset();
+   Int_t index[2] = {(Int_t)mother->GetDaughter(0), (Int_t)mother->GetDaughter(1)};
+   Int_t ntracks = listAOD->GetEntriesFast();
+   Int_t i, pdg;
+   Short_t charge;
+   AliAODMCParticle *daughter = 0x0;
+   for (i = 0; i < 2; i++) {
+      // check index for stack
+      if (index[i] < 0 || index[i] > ntracks) {
+         AliError(Form("Index %d overflow: value = %d, max = %d", i, index[i], ntracks));
+         return kFALSE;
+      }
+      // get daughter and its PDG and charge
+      daughter = (AliAODMCParticle*)listAOD->At(index[i]);
+      pdg      = TMath::Abs(daughter->GetPdgCode());
+      charge   = (Short_t)(daughter->Charge() / 3);
+      // check if it matches one definition
+      if (fPairDef->GetDef1().MatchesPDG(pdg) && fPairDef->GetDef1().MatchesChargeS(charge)) {
+         fDaughter[0].SetGood();
+         fDaughter[0].SetRefMC(daughter);
+         fDaughter[0].SetLabel(index[i]);
+      } else if (fPairDef->GetDef2().MatchesPDG(pdg) && fPairDef->GetDef2().MatchesChargeS(charge)) {
+         fDaughter[1].SetGood();
+         fDaughter[1].SetRefMC(daughter);
+         fDaughter[1].SetLabel(index[i]);
+      }
+   }
+   
+   // return success if both daughters were assigned
+   if (fDaughter[0].IsOK() && fDaughter[1].IsOK()) {
+      return kTRUE;
+   } else {
+      fDaughter[0].Reset();
+      fDaughter[1].Reset();
+      return kFALSE;
+   }
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnLoopPair::LoopTrueMC(AliRsnEvent *rsn)
+{
+//
+// Loop on event and fill containers
+//
+
+   // check presence of MC reference
+   if (!rsn->GetRefMC()) {
+      AliError("Need a MC to compute efficiency");
+      return 0;
+   }
+   
+   // check event type:
+   // must be ESD or AOD, and then use a bool to know in the rest
+   if (!rsn->IsESD() && !rsn->IsAOD()) {
+      AliError("Need to process ESD or AOD input");
+      return 0;
+   }
+   
+   // retrieve the MC primary vertex position
+   // and do some additional coherence checks
+   //Double_t fVertex[3] = {0.0, 0.0, 0.0};
+   Int_t npart = 0;
+   if (rsn->IsESD()) {
+      //TArrayF mcVertex(3);
+      //AliGenEventHeader *genEH = rsn->GetRefMCESD()->GenEventHeader();
+      //genEH->PrimaryVertex(mcVertex);
+      //for (i = 0; i < 3; i++) fVertex[i] = (Double_t)mcVertex[i];
+      npart = rsn->GetRefMCESD()->GetNumberOfTracks();
+   } else {
+      //for (i = 0; i < 3; i++) fVertex[i] = 0.0;
+      AliAODEvent *aod = rsn->GetRefMCAOD();
+      TClonesArray *listAOD = (TClonesArray*)(aod->GetList()->FindObject(AliAODMCParticle::StdBranchName()));
+      if (listAOD) npart = listAOD->GetEntries();
+      //AliAODMCHeader *mcH = static_cast<AliAODMCHeader*>(aod->FindListObject(AliAODMCHeader::StdBranchName()));
+      //if (mcH) mcH->GetVertex(fVertex);
+   }
+   
+   // check number of particles
+   if (!npart) {
+      AliInfo("Empty event");
+      return 0;
+   }
+   
+   // utility variables
+   Int_t ipart, count = 0;
+   AliRsnDaughter check;
+   
+   TObjArrayIter next(&fOutputs);
+   AliRsnListOutput *out = 0x0;
+   
+   // loop over particles
+   for (ipart = 0; ipart < npart; ipart++) {
+      // check i-th particle
+      if (!AssignMotherAndDaughters(rsn, ipart)) continue;
+      // if assignment was successful, for first step, use MC info
+      fDaughter[0].SetRef(fDaughter[0].GetRefMC());
+      fDaughter[1].SetRef(fDaughter[1].GetRefMC());
+      fMother.SetRefEvent(rsn);
+      fMother.ComputeSum(fPairDef->GetDef1().GetMass(), fPairDef->GetDef2().GetMass(), fPairDef->GetMotherMass());
+      // check rapidity range
+      if (TMath::Abs(fMother.Rapidity(0)) > fRangeY) {
+         AliDebugClass(2, Form("[%s]: Outside rapidity range", GetName()));
+         continue;
+      }
+      // fill outputs
+      next.Reset();
+      while ( (out = (AliRsnListOutput*)next()) ) {
+         if (out->Fill(&fMother)) count++;
+         else AliDebugClass(3, Form("[%s]: failed computation", GetName()));
+      }
+   }
+   
+   return count;
+}
index 4636af8..812ccea 100644 (file)
@@ -3,22 +3,26 @@
 
 //
 // Class to combine pairs of daughters.
+// See general definition inf mother class AliRsnLoop
+// This is the only implementation which takes into account mixing objects.
 //
 
-#include "AliRsnPairDef.h"
 #include "AliRsnLoop.h"
 
 class TList;
+class AliRsnEvent;
+class AliRsnPairDef;
 
 class AliRsnLoopPair : public AliRsnLoop {
 public:
 
    AliRsnLoopPair(const char *name = "default", AliRsnPairDef *def = 0, Bool_t isMixed = kFALSE);
    AliRsnLoopPair(const AliRsnLoopPair &copy);
-   AliRsnLoopPair& operator=(const AliRsnLoopPair&);
+   AliRsnLoopPair& operator=(const AliRsnLoopPair &copy);
    ~AliRsnLoopPair();
 
    // getters
+   Bool_t         IsTrueMC()     const {return fTrueMC;}
    Bool_t         IsOnlyTrue()   const {return fOnlyTrue;}
    Bool_t         IsCheckDecay() const {return fCheckDecay;}
    AliRsnPairDef* GetPairDef()         {return fPairDef;}
@@ -27,9 +31,11 @@ public:
 
    // setters (not for all members)
    void           SetPairCuts(AliRsnCutSet *cuts)      {fPairCuts = cuts;}
+   void           SetTrueMC(Bool_t yn = kTRUE)         {fTrueMC = yn;}
    void           SetOnlyTrue(Bool_t onlyTrue = kTRUE) {fOnlyTrue = onlyTrue;}
    void           SetCheckDecay(Bool_t check = kTRUE)  {fCheckDecay = check;}
    void           SetListID(Int_t i, Int_t val)        {if (i==0||i==1) fListID[i] = val;}
+   void           SetRangeY(Double_t range)            {fRangeY = range;}
 
    // methods
    Bool_t         IsTrueMother();
@@ -39,9 +45,16 @@ public:
 
 protected:
 
+   Bool_t AssignMotherAndDaughters   (AliRsnEvent *event, Int_t ipart);
+   Bool_t AssignMotherAndDaughtersESD(AliRsnEvent *event, Int_t ipart);
+   Bool_t AssignMotherAndDaughtersAOD(AliRsnEvent *event, Int_t ipart);
+   Int_t  LoopTrueMC(AliRsnEvent *event);
+
+   Bool_t            fTrueMC;          //  if this flag is TRUE, scan the MC for all true resonances from MC
    Bool_t            fOnlyTrue;        //  select true pairs only?
    Bool_t            fCheckDecay;      //  is the decay channel correct in a true pair?
    Int_t             fListID[2];       //  indexes of the two entry lists to be used
+   Double_t          fRangeY;          //  range in rapidity (serves always)
 
    AliRsnPairDef    *fPairDef;         //  pair definition
    AliRsnCutSet     *fPairCuts;        //  collection of all cuts
@@ -50,7 +63,7 @@ protected:
 
 private:
 
-   ClassDef(AliRsnLoopPair, 2)
+   ClassDef(AliRsnLoopPair, 3)
 };
 
 #endif
index 3006346..3700074 100644 (file)
@@ -31,7 +31,6 @@
 
 #include "AliAODMCParticle.h"
 #include "AliMCParticle.h"
-#include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
 
 #include "AliRsnMother.h"
index f87084f..14408f4 100644 (file)
@@ -11,6 +11,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include <TMath.h>
+#include <TLorentzVector.h>
+
 #include "AliRsnDaughter.h"
 
 class AliRsnEvent;
@@ -34,6 +36,7 @@ public:
    TLorentzVector&   Sum(Bool_t mc)              {return (mc ? fSumMC : fSum);}
    TLorentzVector&   Ref(Bool_t mc)              {return (mc ? fRefMC : fRef);}
    Bool_t            GetResolution(Double_t &value);
+   Double_t          Rapidity(Bool_t mc)         {if (mc) return fRefMC.Rapidity(); else return fRef.Rapidity();}
    
    // checks
    Bool_t    IsLabelEqual()  const {return TMath::Abs(fDaughter[0]->GetLabel()) == TMath::Abs(fDaughter[1]->GetLabel());}
@@ -53,7 +56,7 @@ public:
 
 private:
 
-   Int_t CkID(Int_t i) {if (i < 1) return 0; else return 1;}
+   Int_t CkID(Int_t i) const {if (i < 1) return 0; else return 1;}
 
    AliRsnDaughter  *fDaughter[2];      // elements of the pair
    AliRsnEvent     *fRefEvent;         // reference event
index bd9d524..fd188ec 100644 (file)
@@ -33,18 +33,18 @@ public:
    AliRsnTarget& operator=(const AliRsnTarget& copy) { TNamed::operator=(copy); fTargetType = copy.fTargetType; return (*this); }
    virtual ~AliRsnTarget() { /*nothing*/ }
 
-   Bool_t           IsAllNull()                       {return (!fDaughter && !fMother && !fEvent);}
-   Bool_t           IsTarget(ETargetType targetType)  {return (fTargetType == targetType);}
+   Bool_t           IsAllNull() const                      {return (!fDaughter && !fMother && !fEvent);}
+   Bool_t           IsTarget(ETargetType targetType) const {return (fTargetType == targetType);}
    Bool_t           TargetOK(TObject *object);
    
-   void             SetTargetType(ETargetType type)   {fTargetType = type;}
-   ETargetType      GetTargetType() const             {return fTargetType;}
-   Char_t           GetTargetTypeChar() const;
-   const char*      GetTargetTypeName() const;
-   
-   AliRsnDaughter*  GetTargetDaughter()               {return fDaughter;}
-   AliRsnMother*    GetTargetMother()                 {return fMother;}
-   AliRsnEvent*     GetTargetEvent()                  {return fEvent;}
+   void             SetTargetType(ETargetType type)        {fTargetType = type;}
+   ETargetType      GetTargetType() const                  {return fTargetType;}
+   Char_t           GetTargetTypeChar() const;            
+   const char*      GetTargetTypeName() const;            
+                                                         
+   AliRsnDaughter*  GetTargetDaughter()                    {return fDaughter;}
+   AliRsnMother*    GetTargetMother()                      {return fMother;}
+   AliRsnEvent*     GetTargetEvent()                       {return fEvent;}
 
 protected:
 
index 07507a7..d7887b7 100644 (file)
@@ -37,6 +37,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+#include <Riostream.h>
 #include "AliVVertex.h"
 #include "AliMultiplicity.h"
 #include "AliESDtrackCuts.h"
@@ -44,6 +45,7 @@
 #include "AliAODPid.h"
 #include "AliCentrality.h"
 #include "AliESDUtils.h"
+#include "AliPIDResponse.h"
 
 #include "AliRsnEvent.h"
 #include "AliRsnDaughter.h"
@@ -98,14 +100,17 @@ const char* AliRsnValueDaughter::GetTypeName() const
 //
 
    switch (fType) {
-      case kP:         return "SingleTrackPtot";
-      case kPt:        return "SingleTrackPt";
-      case kPtpc:      return "SingleTrackPtpc";
-      case kEta:       return "SingleTrackEta";
-      case kITSsignal: return "SingleTrackITSsignal";
-      case kTPCsignal: return "SingleTrackTPCsignal";
-      case kTOFsignal: return "SingleTrackTOFsignal";
-      default:         return "Undefined";
+      case kP:           return "SingleTrackPtot";
+      case kPt:          return "SingleTrackPt";
+      case kPtpc:        return "SingleTrackPtpc";
+      case kEta:         return "SingleTrackEta";
+      case kITSsignal:   return "SingleTrackITSsignal";
+      case kTPCsignal:   return "SingleTrackTPCsignal";
+      case kTOFsignal:   return "SingleTrackTOFsignal";
+      case kTOFnsigmaPi: return "SingleTrackTOFnsigmaPion";
+      case kTOFnsigmaK:  return "SingleTrackTOFnsigmaKaon";
+      case kTOFnsigmaP:  return "SingleTrackTOFnsigmaProton";
+      default:           return "Undefined";
    }
 }
 
@@ -126,8 +131,17 @@ Bool_t AliRsnValueDaughter::Eval(TObject *object)
    if (!TargetOK(object)) return kFALSE;
 
    // set a reference to the mother momentum
-   TLorentzVector &p     = fDaughter->P(fUseMCInfo);
+   AliVParticle   *ref   = fDaughter->GetRef();
+   AliVParticle   *refMC = fDaughter->GetRefMC();
    AliVTrack      *track = fDaughter->Ref2Vtrack();
+   if (fUseMCInfo && !refMC) {
+      AliError("No MC");
+      return kFALSE;
+   }
+   if (!fUseMCInfo && !ref) {
+      AliError("No DATA");
+      return kFALSE;
+   }
    
    // compute value depending on types in the enumeration
    // if the type does not match any available choice, or if
@@ -136,13 +150,13 @@ Bool_t AliRsnValueDaughter::Eval(TObject *object)
    // the method returng kFALSE and sets the computed value to a meaningless number
    switch (fType) {
       case kP:
-         fComputedValue = p.Mag();
+         fComputedValue = (fUseMCInfo ? refMC->P() : ref->P());
          return kTRUE;
       case kPt:
-         fComputedValue = p.Perp();
+         fComputedValue = (fUseMCInfo ? refMC->Pt() : ref->Pt());
          return kTRUE;
       case kEta:
-         fComputedValue = p.Eta();
+         fComputedValue = (fUseMCInfo ? refMC->Eta() : ref->Eta());
          return kTRUE;
       case kPtpc:
          if (track) {
@@ -180,6 +194,36 @@ Bool_t AliRsnValueDaughter::Eval(TObject *object)
             fComputedValue = 0.0;
             return kFALSE;
          }
+      case kTOFnsigmaPi:
+         if (track) {
+            AliPIDResponse *pid = fEvent->GetPIDResponse();
+            fComputedValue = pid->NumberOfSigmasTOF(track, AliPID::kPion);
+            return kTRUE;
+         } else {
+            AliWarning("Cannot get TOF signal for non-track object");
+            fComputedValue = 0.0;
+            return kFALSE;
+         }
+      case kTOFnsigmaK:
+         if (track) {
+            AliPIDResponse *pid = fEvent->GetPIDResponse();
+            fComputedValue = pid->NumberOfSigmasTOF(track, AliPID::kKaon);
+            return kTRUE;
+         } else {
+            AliWarning("Cannot get TOF signal for non-track object");
+            fComputedValue = 0.0;
+            return kFALSE;
+         }
+      case kTOFnsigmaP:
+         if (track) {
+            AliPIDResponse *pid = fEvent->GetPIDResponse();
+            fComputedValue = pid->NumberOfSigmasTOF(track, AliPID::kProton);
+            return kTRUE;
+         } else {
+            AliWarning("Cannot get TOF signal for non-track object");
+            fComputedValue = 0.0;
+            return kFALSE;
+         }
       default:
          AliError(Form("[%s] Invalid value type for this computation", GetName()));
          return kFALSE;
index 64cfda8..e333a94 100644 (file)
@@ -23,6 +23,9 @@ public:
       kITSsignal,  // ITS signal
       kTPCsignal,  // TPC signal
       kTOFsignal,  // TOF signal
+      kTOFnsigmaPi,// TOF number of sigmas pion
+      kTOFnsigmaK, // TOF number of sigmas kaon
+      kTOFnsigmaP, // TOF number of sigmas proton
       kTypes
    };
 
index fa02627..1dde193 100644 (file)
@@ -109,6 +109,7 @@ const char* AliRsnValuePair::GetTypeName() const
       case kPtRatio:      return "PairPtRatio";
       case kDipAngle:     return "PairDipAngle";
       case kCosThetaStar: return "PairCosThetaStar";
+      case kAngleLeading: return "PairAngleToLeading";
       default:            return "Undefined";
    }
 }
@@ -133,6 +134,9 @@ Bool_t AliRsnValuePair::Eval(TObject *object)
    TLorentzVector &p1    = fMother->GetDaughter(0)->P(fUseMCInfo);
    TLorentzVector &p2    = fMother->GetDaughter(1)->P(fUseMCInfo);
    
+   // utility variables
+   Bool_t success;
+   
    // compute value depending on types in the enumeration
    // if the type does not match any available choice, or if
    // the computation is not doable due to any problem
@@ -169,6 +173,9 @@ Bool_t AliRsnValuePair::Eval(TObject *object)
       case kCosThetaStar:
          fComputedValue = fMother->CosThetaStar();
          return kTRUE;
+      case kAngleLeading:
+         fComputedValue = fMother->AngleToLeading(success);
+         return success;
       default:
          AliError(Form("[%s] Invalid value type for this computation", GetName()));
          return kFALSE;
index 772decf..ec26b93 100644 (file)
@@ -26,6 +26,7 @@ public:
       kPtRatio,       // ratio |pt1 - pt2|/(pt1 + pt2) of daughter transverse momenta
       kDipAngle,      // inverse cosine of the angle between daughter vector momenta
       kCosThetaStar,  // polarization angle
+      kAngleLeading,  // angle to leading particle
       kTypes
    };