AliForwardUtil.h

Go to the documentation of this file.

// 
// Utilities used in the forward multiplcity analysis 
// 
//
#ifndef ALIFORWARDUTIL_H
#define ALIFORWARDUTIL_H

#include <TObject.h>
#include <TString.h>
#include <TObjArray.h>
class TH2D;
class TH1I;
class TH1;
class TF1;
class TAxis;
class TArrayD;
class TVector3;
class AliVEvent;
class AliESDEvent;
class AliAODEvent;
class AliAnalysisTaskSE;

class AliForwardUtil : public TObject
{
public:
  enum {
    kInvalidValue = -9999
  };
  enum { 
    kSkipRing = (1 << 19) // Bit for skipping a histogram
  };
  static Color_t RingColor(UShort_t d, Char_t r)
  {
#if 0
    return ((d == 1 ? kRed : (d == 2 ? kGreen : kBlue))
      + ((r == 'I' || r == 'i') ? 2 : -3));
#else
    // Brigher colours that look better in print 
    return ((d == 1 ? kRed : (d == 2 ? kGreen : kBlue))
      + ((r == 'I' || r == 'i') ? -3 : -9));
#endif
  }
  //==================================================================
  static ULong_t AliROOTRevision();
  static ULong_t AliROOTBranch();
  /* @} */
  //==================================================================
  enum ECollisionSystem {
    kUnknown, 
    kPP, 
    kPbPb,
    kPPb,
    kPbp,
    kXeXe
  };
  //__________________________________________________________________
  static Float_t BeamRapidity(Float_t beam, UShort_t z, UShort_t a);
  static Float_t CenterOfMassEnergy(Float_t beam, UShort_t z1, UShort_t a1, 
            Short_t z2=-1, Short_t a2=-1);
  static Float_t CenterOfMassRapidity(UShort_t z1, UShort_t a1, 
              Short_t z2=-1, Short_t a2=-1);
  static UShort_t ParseCollisionSystem(const char* sys);
  static UShort_t ParseCollisionSystem(Int_t b1a, Int_t b1z,
               Int_t b2a, Int_t b2z,
               const char* sys);
  static const char* CollisionSystemString(UShort_t sys);
  //__________________________________________________________________
  static UShort_t ParseCenterOfMassEnergy(UShort_t sys, Float_t cms);
  static const char* CenterOfMassEnergyString(UShort_t cms);
  //__________________________________________________________________
  static Short_t ParseMagneticField(Float_t field);
  static const char* MagneticFieldString(Short_t field);
  /* @} */

  //==================================================================
  static Double_t GetStripR(Char_t ring, UShort_t strip);
  static Double_t GetSectorZ(UShort_t det, Char_t ring, UShort_t sec);
  static Double_t GetSectorPhi(UShort_t det, Char_t ring, UShort_t sec);
  static Bool_t GetXYZ(UShort_t det, Char_t ring, UShort_t sec,
           UShort_t str, const TVector3& ip,
           TVector3& pos);
  static Bool_t GetEtaPhi(UShort_t det, Char_t ring, UShort_t sec,
        UShort_t str, const TVector3& ip,
        Double_t& eta, Double_t& phi);
  static Double_t GetEtaFromStrip(UShort_t det, Char_t ring, 
          UShort_t sec, UShort_t strip, Double_t zvtx);
  static Bool_t GetEtaPhiFromStrip(Char_t r, UShort_t strip,
           Double_t& eta, Double_t& phi , 
           Double_t ipX,  Double_t ipY);
  static Double_t GetPhiFromStrip(Char_t ring, UShort_t strip, 
          Double_t phi, Double_t xvtx, Double_t yvtx);
  /* @} */

  //==================================================================
  static AliAODEvent* GetAODEvent(AliAnalysisTaskSE* task);
  static UShort_t CheckForAOD();
  static Bool_t CheckForTask(const char* clsOrName, Bool_t cls=true);
  /* @} */

  //==================================================================
  static TObject* MakeParameter(const char* name, UShort_t value);
  static TObject* MakeParameter(const char* name, Int_t value);
  static TObject* MakeParameter(const char* name, Double_t value);
  static TObject* MakeParameter(const char* name, Bool_t value);
  static TObject* MakeParameter(const char* name, ULong_t value);
  static void GetParameter(TObject* o, UShort_t& value);
  static void GetParameter(TObject* o, Int_t& value);
  static void GetParameter(TObject* o, Double_t& value);
  static void GetParameter(TObject* o, Bool_t& value);
  static void GetParameter(TObject* o, ULong_t& value);
  /* @} */

  //==================================================================
  static TAxis* MakeFullIpZAxis(Int_t nCenter=20);
  static void MakeFullIpZAxis(Int_t nCenter, TArrayD& bins);
  static void MakeLogScale(Int_t nBins, Int_t minOrder, Int_t maxOrder,
         TArrayD& bins);
  /* @} */

  //==================================================================
  static Float_t GetCentrality(const AliVEvent& event, 
             const TString&   method, 
             Int_t&           qual, 
             Bool_t           verbose=false);
  //____________________________________________________________________
  static Float_t GetCentralityMult(const AliVEvent& event, 
           const TString&   method, 
           Int_t&           qual, 
           Bool_t           verbose=false);
  static Float_t GetCentralityCompat(const AliVEvent& event,
             const TString&   method,
             Int_t&           qual,
             Bool_t           verbose);
  //____________________________________________________________________
  static Float_t GetCentralityCompat(const AliESDEvent& event,
             const TString&     method,
             Int_t&             qual,
             Bool_t             verbose);
  //____________________________________________________________________
  static Float_t GetCentralityCompat(const AliAODEvent& event,
             const TString&     method,
             Int_t&             qual,
             Bool_t             verbose);
  
  //==================================================================
  static void PrintTask(const TObject& o);
  static void PrintName(const char* name);
  static void PrintField(const char* name, const char* value, ...);
  /* @} */

  //==================================================================
  struct Histos : public TObject
  { 
    Histos() : fFMD1i(0), fFMD2i(0), fFMD2o(0), fFMD3i(0), fFMD3o(0) {}
    Histos(const Histos& o) 
      : TObject(o), 
  fFMD1i(o.fFMD1i), 
  fFMD2i(o.fFMD2i), 
  fFMD2o(o.fFMD2o), 
  fFMD3i(o.fFMD3i), 
  fFMD3o(o.fFMD3o)
    {}
    Histos& operator=(const Histos&) { return *this;}
    ~Histos();
    void Delete(Option_t* opt="");
    void Init(const TAxis& etaAxis);
    void ReInit(const TAxis& etaAxis);
    static TH2D* Make(UShort_t d, Char_t r, const TAxis& etaAxis);
    static void RebinEta(TH2D* hist, const TAxis& etaAxis);
    void  Clear(Option_t* option="");
    TH2D* Get(UShort_t d, Char_t r) const;
    TH2D* fFMD1i; // Histogram for FMD1i
    TH2D* fFMD2i; // Histogram for FMD2i
    TH2D* fFMD2o; // Histogram for FMD2o
    TH2D* fFMD3i; // Histogram for FMD3i
    TH2D* fFMD3o; // Histogram for FMD3o

    ClassDef(Histos,2);
  };

  //__________________________________________________________________
  struct RingHistos : public TObject
  {
    RingHistos() : fDet(0), fRing('\0'), fName(""), fkNSector(0), fkNStrip(0) {}
    RingHistos(UShort_t d, Char_t r) 
      : fDet(d), fRing(r), fName(TString::Format("FMD%d%c", d, r)),
  fkNSector(r == 'i' || r == 'I' ? 20 : 40), 
  fkNStrip(r == 'i' || r == 'I' ? 512 : 256)
    {}
    RingHistos(const RingHistos& o) 
      : TObject(o), fDet(o.fDet), fRing(o.fRing), fName(o.fName),
  fkNSector(o.fkNSector), fkNStrip(o.fkNStrip)
    {}
    virtual ~RingHistos() {}
    RingHistos& operator=(const RingHistos& o) 
    {
      if (&o == this) return *this;
      TObject::operator=(o);
      fDet  = o.fDet;
      fRing = o.fRing;
      fName = o.fName;
      fkNSector = o.fkNSector;
      fkNStrip  = o.fkNStrip;
      return *this;
    }
    TList* DefineOutputList(TList* d) const;
    TList* GetOutputList(const TList* d) const;
    TH1* GetOutputHist(const TList* d, const char* name) const;
    Color_t Color() const 
    { 
      return AliForwardUtil::RingColor(fDet, fRing);
    }
    const char* GetName() const { return fName.Data(); } 
    const UShort_t& NSector() const { return fkNSector; }
    const UShort_t& NStrip() const { return fkNStrip; }
    UShort_t fDet;   // Detector
    Char_t   fRing;  // Ring
    TString  fName;  // Name
    UShort_t fkNSector; // Number of sectors 
    UShort_t fkNStrip;  // Number of strips 

    ClassDef(RingHistos,1);
  };
  /* @} */

  //__________________________________________________________________
  struct DebugGuard 
  {
    DebugGuard(Int_t lvl, Int_t msgLvl, const char* format, ...);
    ~DebugGuard();
    static void Message(Int_t lvl, Int_t msgLvl, const char* format, ...);
  private:
    static void Output(int in, TString& msg);
    static void Format(TString& out, const char* format, va_list ap);
    TString fMsg;
  };
  //__________________________________________________________________
  struct SuppressGuard
  {
    Int_t save;
    SuppressGuard(Int_t lvl=2000);
    ~SuppressGuard();
  };
private:
  AliForwardUtil() {}
  AliForwardUtil(const AliForwardUtil& o) : TObject(o) {}
  AliForwardUtil& operator=(const AliForwardUtil&) { return *this; }
  ~AliForwardUtil() {}
  

  ClassDef(AliForwardUtil,1);// Utilities - do not make object
};

// #ifdef LOG_NO_DEBUG
// # define DGUARD(L,N,F,...) do {} while(false) 
// #else
# define DGUARD(L,N,F,...)          \
  AliForwardUtil::DebugGuard _GUARD(L,N,F, ## __VA_ARGS__)

# define DMSG(L,N,F,...)          \
  AliForwardUtil::DebugGuard::Message(L,N,F, ## __VA_ARGS__)
// #endif
#endif
// Local Variables:
//  mode: C++
// End: