Protection against negative argument of log, add histograms to study shape/size of...

[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnMiniAnalysisTask.h

diff --git a/PWG2/RESONANCES/AliRsnMiniAnalysisTask.h b/PWG2/RESONANCES/AliRsnMiniAnalysisTask.h
index 5af424a47d2b66be444a239dde01be9c0477a5f3..69bb436361de0570bd9944ed615b2db01112e26d 100644 (file)
--- a/PWG2/RESONANCES/AliRsnMiniAnalysisTask.h
+++ b/PWG2/RESONANCES/AliRsnMiniAnalysisTask.h
@@ -10,16 +10,17 @@
 // -- values to be computed.
 //
 
-#include "AliAnalysisTaskSE.h"
-
 #include <TString.h>
 #include <TClonesArray.h>
 
+#include "AliAnalysisTaskSE.h"
+
 #include "AliRsnEvent.h"
 #include "AliRsnMiniValue.h"
 #include "AliRsnMiniOutput.h"
 
 class TList;
+
 class AliTriggerAnalysis;
 class AliRsnMiniEvent;
 class AliRsnCutSet;
@@ -29,48 +30,52 @@ class AliRsnMiniAnalysisTask : public AliAnalysisTaskSE {
 public:
 
    AliRsnMiniAnalysisTask();
-   AliRsnMiniAnalysisTask(const char *name);
+   AliRsnMiniAnalysisTask(const char *name, Bool_t isMC = kFALSE);
    AliRsnMiniAnalysisTask(const AliRsnMiniAnalysisTask &copy);
    AliRsnMiniAnalysisTask& operator=(const AliRsnMiniAnalysisTask &copy);
    virtual ~AliRsnMiniAnalysisTask();
 
-   virtual void        UserCreateOutputObjects();
-   virtual void        UserExec(Option_t *option);
-   virtual void        Terminate(Option_t *);
-   virtual void        FinishTaskOutput();
-                       
+   void                UseMC(Bool_t yn = kTRUE)           {fUseMC = yn;}                     
+   void                UseCentrality(const char *type)    {fUseCentrality = kTRUE; fCentralityType = type; fCentralityType.ToUpper();}
+   void                UseMultiplicity(const char *type)  {fUseCentrality = kFALSE; fCentralityType = type; fCentralityType.ToUpper();}
+   void                UseContinuousMix()                 {fContinuousMix = kTRUE;}
+   void                UseBinnedMix()                     {fContinuousMix = kFALSE;}
    void                SetNMix(Int_t nmix)                {fNMix = nmix;}
    void                SetMaxDiffMult (Double_t val)      {fMaxDiffMult  = val;}
    void                SetMaxDiffVz   (Double_t val)      {fMaxDiffVz    = val;}
    void                SetMaxDiffAngle(Double_t val)      {fMaxDiffAngle = val;}
    void                SetEventCuts(AliRsnCutSet *cuts)   {fEventCuts    = cuts;}
-   void                UseCentrality(const char *type)    {fUseCentrality = kTRUE; fCentralityType = type; fCentralityType.ToUpper();}
-   void                UseMultiplicity(const char *type)  {fUseCentrality = kFALSE; fCentralityType = type; fCentralityType.ToUpper();}
    Int_t               AddTrackCuts(AliRsnCutSet *cuts);
+   TClonesArray       *Outputs()                          {return &fHistograms;}
+   TClonesArray       *Values()                           {return &fValues;}
    
-   TClonesArray       *Outputs()        {return &fHistograms;}
-   TClonesArray       *Values()         {return &fValues;}
+   virtual void        UserCreateOutputObjects();
+   virtual void        UserExec(Option_t*);
+   virtual void        Terminate(Option_t*);
+   virtual void        FinishTaskOutput();
    
    Int_t               ValueID(AliRsnMiniValue::EType type, Bool_t useMC = kFALSE);
    Int_t               CreateValue(AliRsnMiniValue::EType type, Bool_t useMC = kFALSE); 
    AliRsnMiniOutput   *CreateOutput(const char *name, AliRsnMiniOutput::EOutputType type, AliRsnMiniOutput::EComputation src);
    AliRsnMiniOutput   *CreateOutput(const char *name, const char *outType, const char *compType);
-   
-   void                ProcessEvents(AliRsnMiniEvent *evMain, AliRsnMiniEvent *evMix = 0x0);
   
 private:
 
-   void     InitHistograms(TClonesArray *array);
    Char_t   CheckCurrentEvent();
+   void     FillMiniEvent(Char_t evType);
+   Double_t ComputeAngle();
    Double_t ComputeCentrality(Bool_t isESD);
    void     FillTrueMotherESD(AliRsnMiniEvent *event);
    void     FillTrueMotherAOD(AliRsnMiniEvent *event);
    void     StoreTrueMother(AliRsnMiniPair *pair, AliRsnMiniEvent *event);
+   Bool_t   EventsMatch(AliRsnMiniEvent *event1, AliRsnMiniEvent *event2);
 
+   Bool_t               fUseMC;           //  use or not MC info
    Int_t                fEvNum;           //! absolute event counter
    Bool_t               fUseCentrality;   //  if true, use centrality for event, otherwise use multiplicity
    TString              fCentralityType;  //  definition used to choose what centrality or multiplicity to use
                        
+   Bool_t               fContinuousMix;   //  mixing --> technique chosen (continuous or binned)
    Int_t                fNMix;            //  mixing --> required number of mixes
    Double_t             fMaxDiffMult;     //  mixing --> max difference in multiplicity
    Double_t             fMaxDiffVz;       //  mixing --> max difference in Vz of prim vert
@@ -84,11 +89,13 @@ private:
    AliRsnCutSet        *fEventCuts;       //  cuts on events
    TObjArray            fTrackCuts;       //  list of single track cuts
    AliRsnEvent          fRsnEvent;        //! interface object to the event
-   TTree               *fTempTree;        //! tree to contain converted events (temporary)
-   TArrayI              fNMixed;          //! array to keep trace of how many times an event was mixed
+   TTree               *fEvBuffer;        //! mini-event buffer
    AliTriggerAnalysis  *fTriggerAna;      //! trigger analysis
+   AliESDtrackCuts     *fESDtrackCuts;    //! quality cut for ESD tracks
+   AliRsnMiniEvent     *fMiniEvent;       //! mini-event cursor
+   Bool_t               fBigOutput;       // flag if open file for output list
 
-   ClassDef(AliRsnMiniAnalysisTask, 1); // AliRsnMiniAnalysisTask
+   ClassDef(AliRsnMiniAnalysisTask, 2);   // AliRsnMiniAnalysisTask
 };
 
 inline Int_t AliRsnMiniAnalysisTask::CreateValue(AliRsnMiniValue::EType type, Bool_t useMC)