AliAODTracklet.C

Go to the documentation of this file.

#ifndef ALIAODTRACKLET_C
#define ALIAODTRACKLET_C
#include <TObject.h>
#ifndef __CINT__
# include <TMath.h>
# include <TString.h>
#endif

//====================================================================
class AliAODTracklet : public TObject
{
public:
  enum {
    kInjection      = 0x01,
    kCombinatorics  = 0x02,
    kSecondary      = 0x04,
    kDistinct       = 0x08,
    kSimulated      = 0x10,
    kGenerated      = 0x20,
    kNeutral        = 0x40,
    kSuppressed     = 0x80
  };
    
  typedef Float_t Real_t;
  AliAODTracklet();
  AliAODTracklet(const AliAODTracklet& other);
  virtual ~AliAODTracklet() {}
  AliAODTracklet& operator=(const AliAODTracklet& other);

  void SetTheta(Real_t x) { fTheta = x; }
  void SetPhi(Real_t x) { fPhi = x; }
  void SetDTheta(Real_t x) { fDTheta = x; }
  void SetDPhi(Real_t x) { fDPhi = x; }
  void SetDelta(Real_t x) { fDelta = x; }
  void SetFlags(UChar_t x) { fFlags = x; }
  void SetInjection() { fFlags |= kInjection; }
  void SetCombinatorics() { fFlags |= kCombinatorics; }
  void SetSecondary() { fFlags |= kSecondary; }
  void SetDistinct() { fFlags |= kDistinct; }
  void SetSimulated() { fFlags |= kSimulated; }
  void SetGenerated() { fFlags |= kGenerated; }
  void SetNeutral() { fFlags |= kNeutral; }
  void SetSuppressed() { fFlags |= kSuppressed; }
  /* @} */
  Real_t GetTheta() const { return fTheta; }
  Real_t GetPhi() const { return fPhi; }
  Real_t GetDTheta() const { return fDTheta; }
  Real_t GetDPhi() const { return fDPhi; }
  Real_t GetDelta() const { return fDelta; }
  UChar_t GetFlags() const { return fFlags; }
  /* @} */
  Real_t GetEta() const { return -TMath::Log(TMath::Tan(fTheta/2)); }
  Bool_t IsMeasured() const { return !IsInjection() && !IsGenerated(); }
  Bool_t IsInjection() const { return fFlags & kInjection; }
  Bool_t IsCombinatorics() const { return fFlags & kCombinatorics; }
  Bool_t IsDistinct() const { return fFlags & kDistinct; }
  Bool_t IsSimulated() const { return fFlags & kSimulated; }
  Bool_t IsSecondary() const { return fFlags & kSecondary; }
  Bool_t IsPrimary() const { return (IsSimulated() &&
             !IsSecondary() &&
             !IsCombinatorics() &&
             !IsGenerated()); }
  Bool_t IsGenerated() const { return fFlags & kGenerated; }
  Bool_t IsNeutral() const { return fFlags & kNeutral; }
  Bool_t IsSuppressed() const { return fFlags & kSuppressed; }
  /* @} */
  virtual Real_t GetParentPt(Bool_t second=false) const { return 0; }
  virtual Short_t GetParentPdg(Bool_t second=false) const { return 0; }
  /* @} */
  void Print(Option_t* option="") const;
protected:
  Real_t fTheta;
  Real_t fPhi;
  Real_t fDTheta;
  Real_t fDPhi;
  Real_t fDelta;
  UChar_t fFlags;

  ClassDef(AliAODTracklet,2); // Single tracklet
};
//____________________________________________________________________
AliAODTracklet::AliAODTracklet()
  : fTheta(999),
    fPhi(999),
    fDTheta(999),
    fDPhi(999),
    fDelta(-1),
    fFlags(0)
{}
//____________________________________________________________________
AliAODTracklet::AliAODTracklet(const AliAODTracklet& other)
  : TObject(other),
    fTheta(other.fTheta),
    fPhi(other.fPhi),
    fDTheta(other.fDTheta),
    fDPhi(other.fDPhi),
    fDelta(other.fDelta),
    fFlags(other.fFlags)
{}
//____________________________________________________________________
AliAODTracklet&
AliAODTracklet::operator=(const AliAODTracklet& other)
{
  if (&other == this) return *this;
  fTheta  = other.fTheta;
  fPhi    = other.fPhi;
  fDTheta = other.fDTheta;
  fDPhi   = other.fDPhi;
  fDelta  = other.fDelta;
  fFlags  = other.fFlags;
  return *this;
}
//____________________________________________________________________
void AliAODTracklet::Print(Option_t* option) const
{
  char flags[9];
  if (IsMeasured())      flags[0] = 'M'; else flags[0] = '-';
  if (IsInjection())     flags[1] = 'I'; else flags[1] = '-';
  if (IsCombinatorics()) flags[2] = 'C'; else flags[2] = '-'; 
  if (IsDistinct())      flags[3] = 'D'; else flags[3] = '-';
  if (IsSecondary())     flags[4] = 'S'; else flags[4] = '-';
  if (IsPrimary())       flags[5] = 'P'; else flags[5] = '-';
  if (IsGenerated())     flags[6] = 'G'; else flags[6] = '-';
  if (IsSuppressed())    flags[7] = 'S'; else flags[7] = '-';
  flags[8] = '\0';
  printf("Tracklet 0x%02x %s (%6.2f,%6.2f)+/-(%6.2f,%6.2f) [eta=%5.2f]",
   fFlags,
   flags,
   TMath::RadToDeg()*fTheta,
   TMath::RadToDeg()*fPhi,
   TMath::RadToDeg()*fDTheta,
   TMath::RadToDeg()*fDPhi,
   GetEta());
  if (option[0] == 'B') return;
  printf("\n");
}

  
//====================================================================
class AliAODMCTracklet : public AliAODTracklet
{
public:
  AliAODMCTracklet();
  AliAODMCTracklet(const AliAODMCTracklet& other);
  virtual ~AliAODMCTracklet() {}
  AliAODMCTracklet& operator=(const AliAODMCTracklet& other);
  virtual Real_t GetParentPt(Bool_t second=false) const
  {
    return !second ? fPar1Pt : fPar2Pt;
  }
  virtual Short_t GetParentPdg(Bool_t second=false) const
  {
    return !second ? fPar1Pdg : fPar2Pdg;
  }
  void SetParentPt(Real_t pt, Bool_t second=false)
  {
    if (!second) fPar1Pt = pt; else fPar2Pt = pt;
  }
  void SetParentPdg(Short_t pdg, Bool_t second=false)
  {
    if (!second) fPar1Pdg = pdg; else fPar2Pdg = pdg;
  }
  /* @} */
  void Print(Option_t* option="") const;
protected:
  Real_t fPar1Pt; 
  Real_t fPar2Pt; 
  Short_t fPar1Pdg; 
  Short_t fPar2Pdg; 
  
  ClassDef(AliAODMCTracklet,2); // Single tracklet information (sim)
};
  
//____________________________________________________________________
AliAODMCTracklet::AliAODMCTracklet()
  : AliAODTracklet(),
    fPar1Pt(-1),
    fPar2Pt(-1),
    fPar1Pdg(0),
    fPar2Pdg(0)    
{}
//____________________________________________________________________
AliAODMCTracklet::AliAODMCTracklet(const AliAODMCTracklet& other)
  : AliAODTracklet(other),
    fPar1Pt(other.fPar1Pt),
    fPar2Pt(other.fPar2Pt),
    fPar1Pdg(other.fPar1Pdg),
    fPar2Pdg(other.fPar2Pdg)    
{
  SetSimulated();
}
//____________________________________________________________________
AliAODMCTracklet&
AliAODMCTracklet::operator=(const AliAODMCTracklet& other)
{
  if (&other == this) return *this;
  AliAODTracklet::operator=(other);
  fPar1Pt  = other.fPar1Pt;
  fPar2Pt  = other.fPar2Pt;
  fPar1Pdg = other.fPar1Pdg;
  fPar2Pdg = other.fPar2Pdg;    
  return *this;
}

//____________________________________________________________________
void AliAODMCTracklet::Print(Option_t* option) const
{
  AliAODTracklet::Print("B");
  Printf(" [%5d,%5.2f %5d,%5.2f]", fPar1Pdg,fPar1Pt, fPar2Pdg, fPar2Pt);
}

#endif
//____________________________________________________________________
//
// EOF
//