AliAnalysisTaskEmcalJetTree.cxx

Go to the documentation of this file.

/**************************************************************************
 * Copyright(c) 1998-2016, 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 "AliLog.h"
#include "AliAnalysisTaskEmcalJetTree.h"

// Definitions of class AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryBase

ClassImp(AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryBase)

AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryBase::AliEmcalJetInfoSummaryBase(const AliEmcalJetInfo& source) :
  fPt(0),
  fEta(0),
  fPhi(0),
  fNEF(0),
  fZLeading(0)
{
  Set(source);
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryBase::Reset()
{
  fPt = 0;
  fEta = 0;
  fPhi = 0;
  fNEF = 0;
  fZLeading = 0;
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryBase::Set(const AliEmcalJetInfo& source)
{
  fPt = source.Pt();
  fEta = source.Eta();
  fPhi = source.Phi_0_2pi();
  fNEF = source.fNEF;
  fZLeading = source.fZ;
}

// Definitions of class AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPP

ClassImp(AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPP)

AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPP::AliEmcalJetInfoSummaryPP(const AliEmcalJetInfo& source) :
  AliEmcalJetInfoSummaryBase(),
  fNConstituents(0)
{
  Set(source);
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPP::Reset()
{
  AliEmcalJetInfoSummaryBase::Reset();
  fNConstituents = 0;
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPP::Set(const AliEmcalJetInfo& source)
{
  AliEmcalJetInfoSummaryBase::Set(source);
  fNConstituents = Char_t(source.fNConstituents);
}

// Definitions of class AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb

ClassImp(AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb)

AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb::AliEmcalJetInfoSummaryPbPb(const AliEmcalJetInfo& source) :
  AliEmcalJetInfoSummaryBase(),
  fCent(0),
  fEP(0),
  fArea(0),
  fNConstituents(0),
  fCorrPt(0)
{
  Set(source);
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb::Reset()
{
  AliEmcalJetInfoSummaryBase::Reset();
  fCent = 0;
  fEP = 0;
  fArea = 0;
  fNConstituents = 0;
  fCorrPt = 0;
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb::Set(const AliEmcalJetInfo& source)
{
  AliEmcalJetInfoSummaryBase::Set(source);
  fCent = Char_t(source.fCent);
  fEP = source.fEP;
  fArea = source.fArea;
  fNConstituents = Short_t(source.fNConstituents);
  fCorrPt = source.fCorrPt;
}

// Definitions of class AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb

ClassImp(AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryEmbedding)

AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryEmbedding::AliEmcalJetInfoSummaryEmbedding(const AliEmcalJetInfo& source) :
  AliEmcalJetInfoSummaryPbPb(),
  fMCPt(0)
{
  Set(source);
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryEmbedding::Reset()
{
  AliEmcalJetInfoSummaryPbPb::Reset();
  fMCPt = 0;
}

void AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryEmbedding::Set(const AliEmcalJetInfo& source)
{
  AliEmcalJetInfoSummaryPbPb::Set(source);
  fMCPt = source.fMCPt;
}

// Definitions of class AliAnalysisTaskEmcalJetTreeBase

ClassImp(AliAnalysisTaskEmcalJetTreeBase)

AliAnalysisTaskEmcalJetTreeBase::AliAnalysisTaskEmcalJetTreeBase(const char *name) :
  AliAnalysisTaskEmcalJetSpectraQA(name),
  fTree(0)
{
  DefineOutput(2, TTree::Class());
  SetHistoType(kTTree);
}

AliAnalysisTaskEmcalJetTreeBase* AliAnalysisTaskEmcalJetTreeBase::CreateInstance(const char* name, EAnalisysType_t type)
{
  switch (type) {
  case kJetPP:
    ::Info("AliAnalysisTaskEmcalJetTreeBase::CreateInstance", "Created an instance of AliAnalysisTaskEmcalJetTree<AliEmcalJetInfoSummaryPP>");
    return new AliAnalysisTaskEmcalJetTree<AliEmcalJetInfoSummaryPP>(name);
    break;
  case kJetPbPb:
    ::Info("AliAnalysisTaskEmcalJetTreeBase::CreateInstance", "Created an instance of AliAnalysisTaskEmcalJetTree<AliEmcalJetInfoSummaryPbPb>");
    return new AliAnalysisTaskEmcalJetTree<AliEmcalJetInfoSummaryPbPb>(name);
    break;
  case kJetEmbedding:
    ::Info("AliAnalysisTaskEmcalJetTreeBase::CreateInstance", "Created an instance of AliAnalysisTaskEmcalJetTree<AliEmcalJetInfoSummaryEmbedding>");
    return new AliAnalysisTaskEmcalJetTree<AliEmcalJetInfoSummaryEmbedding>(name);
    break;
  default:
    ::Error("AliAnalysisTaskEmcalJetTreeBase::CreateInstance", "Type %d not implemented!", type);
    return 0;
  }
}

// Definitions of class AliAnalysisTaskEmcalJetTree

templateClassImp(AliAnalysisTaskEmcalJetTree)

template <class T>
AliAnalysisTaskEmcalJetTree<T>::AliAnalysisTaskEmcalJetTree() :
  AliAnalysisTaskEmcalJetTreeBase("AliAnalysisTaskEmcalJetTree"),
  fCurrentOutput(0)
{
}

template <>
AliAnalysisTaskEmcalJetTree<AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPP>::AliAnalysisTaskEmcalJetTree() :
  AliAnalysisTaskEmcalJetTreeBase("AliAnalysisTaskEmcalJetTree"),
  fCurrentOutput(0)
{
}

template <>
AliAnalysisTaskEmcalJetTree<AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryPbPb>::AliAnalysisTaskEmcalJetTree() :
  AliAnalysisTaskEmcalJetTreeBase("AliAnalysisTaskEmcalJetTree"),
  fCurrentOutput(0)
{
}

template <>
AliAnalysisTaskEmcalJetTree<AliAnalysisTaskEmcalJetTreeBase::AliEmcalJetInfoSummaryEmbedding>::AliAnalysisTaskEmcalJetTree() :
  AliAnalysisTaskEmcalJetTreeBase("AliAnalysisTaskEmcalJetTree"),
  fCurrentOutput(0)
{
}

template <class T>
AliAnalysisTaskEmcalJetTree<T>::AliAnalysisTaskEmcalJetTree(const char *name) :
  AliAnalysisTaskEmcalJetTreeBase(name),
  fCurrentOutput(0)
{
}

template <class T>
void AliAnalysisTaskEmcalJetTree<T>::AllocateTTree(const AliJetContainer* jets)
{
  typename std::map<std::string,std::vector<T> >::iterator it = (fCurrentOutput->insert(std::pair<std::string,std::vector<T> >(jets->GetName(), std::vector<T>()))).first;
  fTree->Branch(jets->GetName(), &((*it).second));
}

template <class T>
void AliAnalysisTaskEmcalJetTree<T>::UserCreateOutputObjects()
{
  fCurrentOutput = new std::map<std::string, std::vector<T> >();
  TString treeName = TString::Format("%s_jets", GetName());
  fTree = new TTree(treeName, treeName);

  AliAnalysisTaskEmcalJetSpectraQA::UserCreateOutputObjects();

  PostData(2, fTree);
}

template <class T>
void AliAnalysisTaskEmcalJetTree<T>::FillTTree(const AliEmcalJetInfo& jet, const AliJetContainer* jets)
{
  static typename std::map<std::string, std::vector<T> >::iterator it = fCurrentOutput->end();

  if (it == fCurrentOutput->end() || TString(jets->GetName()) != it->first) {
    it = fCurrentOutput->find(jets->GetName());
    if (it == fCurrentOutput->end()) return;
  }

  it->second.push_back(T(jet));
}

template <class T>
Bool_t AliAnalysisTaskEmcalJetTree<T>::FillHistograms()
{
  typedef typename std::map<std::string, std::vector<T> >::iterator iterator_type;

  for (iterator_type it = fCurrentOutput->begin(); it != fCurrentOutput->end(); it++) {
    it->second.clear();
  }

  Bool_t r = AliAnalysisTaskEmcalJetSpectraQA::FillHistograms();
  if (!r) return kFALSE;
  fTree->Fill();
  PostData(2, fTree);
  return kTRUE;
}