AliTrackContainer.cxx

Go to the documentation of this file.

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
#include <TClonesArray.h>

#include "AliAODEvent.h"
#include "AliESDEvent.h"
#include "AliVEvent.h"
#include "AliLog.h"
#include "AliVCuts.h"
#include "AliESDtrack.h"

#include "AliTLorentzVector.h"
#include "AliEmcalTrackSelectionAOD.h"
#include "AliEmcalTrackSelectionESD.h"
#include "AliTrackContainer.h"

ClassImp(AliTrackContainer);

TString AliTrackContainer::fgDefTrackCutsPeriod = "";

AliTrackContainer::AliTrackContainer():
  AliParticleContainer(),
  fTrackFilterType(AliEmcalTrackSelection::kHybridTracks),
  fListOfCuts(0),
  fSelectionModeAny(kFALSE),
  fAODFilterBits(0),
  fTrackCutsPeriod(),
  fEmcalTrackSelection(0),
  fFilteredTracks(0),
  fTrackTypes(5000)
{
  fBaseClassName = "AliVTrack";
  SetClassName("AliVTrack");
  fMassHypothesis = 0.139;
}

AliTrackContainer::AliTrackContainer(const char *name, const char *period):
  AliParticleContainer(name),
  fTrackFilterType(AliEmcalTrackSelection::kHybridTracks),
  fListOfCuts(0),
  fSelectionModeAny(kFALSE),
  fAODFilterBits(0),
  fTrackCutsPeriod(period),
  fEmcalTrackSelection(0),
  fFilteredTracks(0),
  fTrackTypes(5000)
{
  fBaseClassName = "AliVTrack";
  SetClassName("AliVTrack");

  if (fTrackCutsPeriod.IsNull() && !AliTrackContainer::fgDefTrackCutsPeriod.IsNull()) {
    AliInfo(Form("Default track cuts period is %s", AliTrackContainer::fgDefTrackCutsPeriod.Data()));
    fTrackCutsPeriod = AliTrackContainer::fgDefTrackCutsPeriod;
  }
  fMassHypothesis = 0.139;
}

void AliTrackContainer::SetArray(const AliVEvent *event)
{
  AliParticleContainer::SetArray(event);

  if (fTrackFilterType == AliEmcalTrackSelection::kNoTrackFilter) {
    if (fEmcalTrackSelection) delete fEmcalTrackSelection;
    fEmcalTrackSelection = 0;
  }
  else {
    if (fTrackFilterType == AliEmcalTrackSelection::kCustomTrackFilter) {

      AliInfo("Using custom track cuts");

      if (fLoadedClass) {
        if (fLoadedClass->InheritsFrom("AliAODTrack")) {
          AliInfo(Form("Objects are of type %s: AOD track selection will be done.", fLoadedClass->GetName()));
          fEmcalTrackSelection = new AliEmcalTrackSelectionAOD(0, fAODFilterBits);
        }
        else if (fLoadedClass->InheritsFrom("AliESDtrack")) {
          AliInfo(Form("Objects are of type %s: ESD track selection will be done.", fLoadedClass->GetName()));
          fEmcalTrackSelection = new AliEmcalTrackSelectionESD(0);
        }
        else {
          AliWarning(Form("Objects are of type %s: no track filtering will be done!!", fLoadedClass->GetName()));
        }
      }

      if (fEmcalTrackSelection) {
        if (fSelectionModeAny) {
          fEmcalTrackSelection->SetSelectionModeAny();
        }
        else {
          fEmcalTrackSelection->SetSelectionModeAll();
        }

        fEmcalTrackSelection->AddTrackCuts(fListOfCuts);
      }
    }
    else {
      if (!fTrackCutsPeriod.IsNull()) {
        AliInfo(Form("Using track cuts %d for period %s", fTrackFilterType, fTrackCutsPeriod.Data()));
      }
      else {
        AliInfo(Form("Using track cuts %d (no data period was provided!)", fTrackFilterType));
      }

      if (fLoadedClass->InheritsFrom("AliAODTrack")) {
        AliInfo(Form("Objects are of type %s: AOD track selection will be done.", fLoadedClass->GetName()));
        fEmcalTrackSelection = new AliEmcalTrackSelectionAOD(fTrackFilterType, fTrackCutsPeriod);
      }
      else if (fLoadedClass->InheritsFrom("AliESDtrack")) {
        AliInfo(Form("Objects are of type %s: ESD track selection will be done.", fLoadedClass->GetName()));
        fEmcalTrackSelection = new AliEmcalTrackSelectionESD(fTrackFilterType, fTrackCutsPeriod);
      }
      else {
        AliWarning(Form("Objects are of type %s: no track filtering will be done!!", fLoadedClass->GetName()));
      }
    }
  }
}

void AliTrackContainer::NextEvent(const AliVEvent * event)
{
  AliParticleContainer::NextEvent(event);

  fTrackTypes.Reset(kUndefined);
  if (fEmcalTrackSelection) {
    fFilteredTracks = fEmcalTrackSelection->GetAcceptedTracks(fClArray);

    const TClonesArray* trackBitmaps = fEmcalTrackSelection->GetAcceptedTrackBitmaps();
    TIter nextBitmap(trackBitmaps);
    TBits* bits = 0;
    Int_t i = 0;
    while ((bits = static_cast<TBits*>(nextBitmap()))) {
      if (i >= fTrackTypes.GetSize()) fTrackTypes.Set((i+1)*2);
      AliVTrack* vTrack = static_cast<AliVTrack*>(fFilteredTracks->At(i));
      if (!vTrack) {
        fTrackTypes[i] = kRejected;
      }
      else if (fTrackFilterType == AliEmcalTrackSelection::kHybridTracks) {
        if (bits->FirstSetBit() == 0) {
          fTrackTypes[i] = kHybridGlobal;
        }
        else if (bits->FirstSetBit() == 1) {
          if ((vTrack->GetStatus()&AliVTrack::kITSrefit) != 0) {
            fTrackTypes[i] = kHybridConstrained;
          }
          else {
            fTrackTypes[i] = kHybridConstrainedNoITSrefit;
          }
        }
      }
     i++;
    }
  }
  else {
    fFilteredTracks = fClArray;
  }
}

AliVTrack* AliTrackContainer::GetTrack(Int_t i) const
{
  //Get i^th jet in array

  if (i < 0 || i >= fFilteredTracks->GetEntriesFast()) return 0;
  AliVTrack *vp = static_cast<AliVTrack*>(fFilteredTracks->At(i));
  return vp;
}

AliVTrack* AliTrackContainer::GetAcceptTrack(Int_t i) const
{
  UInt_t rejectionReason;
  if (i == -1) i = fCurrentID;
  if (AcceptTrack(i, rejectionReason)) {
      return GetTrack(i);
  }
  else {
    AliDebug(2,"Track not accepted.");
    return 0;
  }
}

AliVTrack* AliTrackContainer::GetNextAcceptTrack()
{
  const Int_t n = GetNEntries();
  AliVTrack *p = 0;
  do {
    fCurrentID++;
    if (fCurrentID >= n) break;
    p = GetAcceptTrack(fCurrentID);
  } while (!p);

  return p;
}

AliVTrack* AliTrackContainer::GetNextTrack()
{
  const Int_t n = GetNEntries();
  AliVTrack *p = 0;
  do {
    fCurrentID++;
    if (fCurrentID >= n) break;
    p = GetTrack(fCurrentID);
  } while (!p);

  return p;
}

Char_t AliTrackContainer::GetTrackType(const AliVTrack* track) const
{
  Int_t id = fFilteredTracks->IndexOf(track);
  if (id >= 0) {
    return fTrackTypes[id];
  }
  else {
    return kUndefined;
  }
}

Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* track, Double_t mass) const
{
  if (track) {
    if (mass < 0) mass = track->M();

    Bool_t useConstrainedParams = kFALSE;
    if (fLoadedClass->InheritsFrom("AliESDtrack") && fTrackFilterType == AliEmcalTrackSelection::kHybridTracks) {
      Char_t trackType = GetTrackType(track);
      if (trackType == kHybridConstrained || trackType == kHybridConstrainedNoITSrefit) {
        useConstrainedParams = kTRUE;
      }
    }

    if (useConstrainedParams) {
      const AliESDtrack *esdtrack = static_cast<const AliESDtrack*>(track);
      mom.SetPtEtaPhiM(esdtrack->GetConstrainedParam()->Pt(), esdtrack->GetConstrainedParam()->Eta(), esdtrack->GetConstrainedParam()->Phi(), mass);
    }
    else {
      mom.SetPtEtaPhiM(track->Pt(), track->Eta(), track->Phi(), mass);
    }
    return kTRUE;
  }
  else {
    mom.SetPtEtaPhiM(0, 0, 0, 0);
    return kFALSE;
  }
}

Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* part) const
{
  return GetMomentumFromTrack(mom,part,fMassHypothesis);
}

Bool_t AliTrackContainer::GetMomentum(TLorentzVector &mom, Int_t i) const
{
  Double_t mass = fMassHypothesis;

  if (i == -1) i = fCurrentID;
  AliVTrack *vp = GetTrack(i);
  if (vp) {
    if (mass < 0) mass = vp->M();

    if (fLoadedClass->InheritsFrom("AliESDtrack") && fTrackFilterType == AliEmcalTrackSelection::kHybridTracks &&
        (fTrackTypes[i] == kHybridConstrained || fTrackTypes[i] == kHybridConstrainedNoITSrefit)) {
      AliESDtrack *track = static_cast<AliESDtrack*>(vp);
      mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
    }
    else {
      mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
    }
    return kTRUE;
  }
  else {
    mom.SetPtEtaPhiM(0, 0, 0, 0);
    return kFALSE;
  }
}

Bool_t AliTrackContainer::GetNextMomentum(TLorentzVector &mom)
{
  Double_t mass = fMassHypothesis;

  AliVTrack *vp = GetNextTrack();
  if (vp) {
    if (mass < 0) mass = vp->M();

    if (fLoadedClass->InheritsFrom("AliESDtrack") && fTrackFilterType == AliEmcalTrackSelection::kHybridTracks &&
        (fTrackTypes[fCurrentID] == kHybridConstrained || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
      AliESDtrack *track = static_cast<AliESDtrack*>(vp);
      mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
    }
    else {
      mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
    }
    return kTRUE;
  }
  else {
    mom.SetPtEtaPhiM(0, 0, 0, 0);
    return kFALSE;
  }
}

Bool_t AliTrackContainer::GetAcceptMomentum(TLorentzVector &mom, Int_t i) const
{

  Double_t mass = fMassHypothesis;

  if (i == -1) i = fCurrentID;
  AliVTrack *vp = GetAcceptTrack(i);
  if (vp) {
    if (mass < 0) mass = vp->M();

    if (fLoadedClass->InheritsFrom("AliESDtrack") && fTrackFilterType == AliEmcalTrackSelection::kHybridTracks &&
        (fTrackTypes[i] == kHybridConstrained || fTrackTypes[i] == kHybridConstrainedNoITSrefit)) {
      AliESDtrack *track = static_cast<AliESDtrack*>(vp);
      mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
    }
    else {
      mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
    }

    return kTRUE;
  }
  else {
    mom.SetPtEtaPhiM(0, 0, 0, 0);
    return kFALSE;
  }
}

Bool_t AliTrackContainer::GetNextAcceptMomentum(TLorentzVector &mom)
{
  Double_t mass = fMassHypothesis;

  AliVTrack *vp = GetNextAcceptTrack();
  if (vp) {
    if (mass < 0) mass = vp->M();

    if (fLoadedClass->InheritsFrom("AliESDtrack") && fTrackFilterType == AliEmcalTrackSelection::kHybridTracks &&
        (fTrackTypes[fCurrentID] == kHybridConstrained || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
      AliESDtrack *track = static_cast<AliESDtrack*>(vp);
      mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
    }
    else {
      mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
    }

    return kTRUE;
  }
  else {
    mom.SetPtEtaPhiM(0, 0, 0, 0);
    return kFALSE;
  }
}

Bool_t AliTrackContainer::AcceptTrack(const AliVTrack *vp, UInt_t &rejectionReason) const
{
  Bool_t r = ApplyTrackCuts(vp, rejectionReason);
  if (!r) return kFALSE;

  AliTLorentzVector mom;
  if(!GetMomentumFromTrack(mom, vp)) return false;

  return ApplyKinematicCuts(mom, rejectionReason);
}

Bool_t AliTrackContainer::AcceptTrack(Int_t i, UInt_t &rejectionReason) const
{
  Bool_t r = ApplyTrackCuts(GetTrack(i), rejectionReason);
  if (!r) return kFALSE;

  AliTLorentzVector mom;
  if(!GetMomentum(mom, i)) return false;

  return ApplyKinematicCuts(mom, rejectionReason);
}

Bool_t AliTrackContainer::ApplyTrackCuts(const AliVTrack* vp, UInt_t &rejectionReason) const
{
  return ApplyParticleCuts(vp, rejectionReason);
}

void AliTrackContainer::AddTrackCuts(AliVCuts *cuts)
{
  if (!fListOfCuts) {
    fListOfCuts = new TObjArray;
    fListOfCuts->SetOwner(true);
  }
  fListOfCuts->Add(cuts);
}

Int_t AliTrackContainer::GetNumberOfCutObjects() const
{
  if (!fListOfCuts) return 0;
  return fListOfCuts->GetEntries();
}

AliVCuts* AliTrackContainer::GetTrackCuts(Int_t icut)
{
  if (!fListOfCuts) return NULL;
  if (icut < fListOfCuts->GetEntries()) {
    return static_cast<AliVCuts *>(fListOfCuts->At(icut));
  }
  return NULL;
}

const AliTrackIterableContainer AliTrackContainer::all() const {
  return AliTrackIterableContainer(this, false);
}

const AliTrackIterableContainer AliTrackContainer::accepted() const {
  return AliTrackIterableContainer(this, true);
}

const AliTrackIterableMomentumContainer AliTrackContainer::all_momentum() const {
  return AliTrackIterableMomentumContainer(this, false);
}

const AliTrackIterableMomentumContainer AliTrackContainer::accepted_momentum() const {
  return AliTrackIterableMomentumContainer(this, true);
}

const char* AliTrackContainer::GetTitle() const
{
  static TString trackString;
  trackString = TString::Format("%s_pT%04d", GetArrayName().Data(), static_cast<int>(GetMinPt()*1000.0));
  return trackString.Data();
}

TString AliTrackContainer::GetDefaultArrayName(const AliVEvent *const ev) const {
  if(ev->IsA() == AliAODEvent::Class()) return "tracks";
  else if(ev->IsA() == AliESDEvent::Class()) return "Tracks";
  else return "";
}