AliAnalysisTaskEmcalJetCDF.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKEMCALJETCDF_H
#define ALIANALYSISTASKEMCALJETCDF_H

/* Copyright(c) 1998-2016, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

#include <TFile.h>
#include <TChain.h>
#include <TH1D.h>
#include <TH2D.h>
#include <TArrayD.h>
#include <TVector2.h>
#include <TString.h>
#include "THistManager.h"
#include "AliLog.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisTaskEmcalJet.h"
#include "AliEmcalEmbeddingQA.h"

class AliAnalysisTaskEmcalJetCDF : public AliAnalysisTaskEmcalJet {
public:

    AliAnalysisTaskEmcalJetCDF();
    AliAnalysisTaskEmcalJetCDF ( const char *name );
    virtual ~AliAnalysisTaskEmcalJetCDF();

    void                        UserCreateOutputObjects();
    void                        Terminate ( Option_t *option );

protected:
    void                        ExecOnce();
    Bool_t                      Run() ;

    Bool_t                      FillHistograms()   ;

    TObject* GetHistogram ( const char* histName );

    Bool_t              IsEventSelected();

    AliEmcalEmbeddingQA         fEmbeddingQA;            

    // Event selection
    Bool_t                      fUseAliEventCuts;                     
    AliEventCuts                fEventCuts;                           
    TList                      *fEventCutList;                        
    Bool_t                      fUseManualEventCuts;                  

    // MC options
    AliMCParticleContainer*     fGeneratorLevel;                      

    THistManager                fHistManager   ;


private:
    AliAnalysisTaskEmcalJetCDF ( const AliAnalysisTaskEmcalJetCDF& );           // not implemented
    AliAnalysisTaskEmcalJetCDF &operator= ( const AliAnalysisTaskEmcalJetCDF& ); // not implemented

    ClassDef ( AliAnalysisTaskEmcalJetCDF, 8 );

};

namespace PWGJE {
namespace EMCALJetTasks {
namespace AliAnalysisTaskEmcalJetCDF_NS {

  typedef std::pair<Double_t, Int_t> ptidx_pair;

  struct sort_descend
    {
    bool operator () ( const ptidx_pair &p1, const ptidx_pair &p2 )  { return p1.first > p2.first ; }
    };

  inline Double_t Mag2 (const AliVParticle& trk)
    { return trk.Px()*trk.Px() + trk.Py()*trk.Py() + trk.Pz()*trk.Pz(); }

  inline Double_t Mag(const AliVParticle& trk) { return TMath::Sqrt(Mag2(trk)); }

  inline Double_t Dot  (const AliVParticle& trk1, const AliVParticle& trk2 )
    { return trk1.Px()*trk2.Px() + trk1.Py()*trk2.Py() + trk1.Pz()*trk2.Pz(); }

  inline Double_t Perp2( const AliVParticle& trk1, const AliVParticle& trk2) {
    Double_t mag1  = Mag2(trk1);
    Double_t mag2  = Mag2(trk2);
    Double_t dotp  = Dot(trk1,trk2);
    if (mag2 > 0.0) { mag1 -= dotp*dotp/mag2; }
    if (mag1 <= 0)  { mag1 = 0; }
    return mag1;
    }

  inline Double_t Perp (const AliVParticle& trk1, const AliVParticle& trk2 ) { return TMath::Sqrt(Perp2(trk1,trk2)); }

  std::vector<Int_t>          SortTracksPt ( AliVEvent* event );

  std::vector<Int_t>          SortTracksPt ( AliParticleContainer* track_container );

  inline Double_t             Z_ptot ( const AliEmcalJet* jet, const AliVParticle* trk ) // Get Z of constituent trk ; p total
    {
    if (trk->P() < 1e-6) return 0.;
    return (trk != 0) ? trk->P()/ jet->P() : 0.;
    }

  inline Double_t             Z_pt   ( const AliEmcalJet* jet, const AliVParticle* trk ) // Get Z of constituent trk ; pt
    {
    if (trk->P() < 1e-6) return 0.;
    return (trk != 0) ? trk->Pt() / jet->Pt() : 0.;
    }

  inline Double_t              Xi ( Double_t z ) { return TMath::Log ( 1/z ); } // Get Xi of value z

  inline Double_t              DeltaR ( const AliVParticle* part1, const AliVParticle* part2 )
    {
    Double_t dPhi = part1->Phi() - part2->Phi();
    Double_t dEta = part1->Eta() - part2->Eta();
    dPhi = TVector2::Phi_mpi_pi ( dPhi );
    return TMath::Sqrt ( dPhi * dPhi + dEta * dEta );
    }

  inline Int_t                IdxInArray ( Int_t index, TArrayI &array )
    {
    for ( Int_t i = 0; i < array.GetSize(); i++ ) { if ( index == array[i] ) { return i; } }
    return -1;
    }

  AliAnalysisTaskEmcalJetCDF* AddTaskEmcalJetCDF (
                                const char* ntracks    = "usedefault",
                                const char* nclusters  = "usedefault",
                                const char* ncells     = "usedefault",
                                const char* ntracks_mc = "",
                                const char* tag        = "CDF"
                              );

  AliJetContainer* jetContSetParams (
                          AliJetContainer* jetCont,
                          Float_t jetptmin = 1.,
                          Float_t jetptmax = 500.,
                          Float_t jetareacutperc = 0.,
                          Int_t leadhadtype = 2,
                          Int_t nLeadJets = 1,
                          Float_t mintrackpt = 0.15,
                          Float_t maxtrackpt = 1000.
                          );


TChain* CreateChain ( const char* filelist = "filelist.txt",
                      const char* cTreeNameArg       = "auto",
                      const char* friends            = "",
                      UInt_t      iNumFiles          = -1,
                      UInt_t      iStartWithFile     =  1
                      );



inline bool PeriodIsMC (const char* str) {
   TString period (str);
   if (!period.IsNull()) {
     period.ToLower();
     if ( period.BeginsWith("lhc") && (period.Length() > 6) ) { return true; }
     }
   return false;
 }


inline TString GetPeriod (const char* file_path) {
   TString period = "";
   TString sFile(file_path);
   sFile.ToLower();

   if (!sFile.IsNull()) {
     // split string in tokens (libs)
     TObjArray* tokens_list = sFile.Tokenize("/");
     tokens_list->SetOwner(kTRUE);
     TIter next_str(tokens_list);
     TObjString* token = NULL;
     while ((token=(TObjString*)next_str())) {
       TString token_str = token->GetString();
       if ( token_str.BeginsWith("lhc") ) { period = token_str; break; }
       }
     delete tokens_list;
     }
   return period;
 }


inline TString GetPass ( const char* file_path) {
   TString pass = "";
   TString sFile (file_path);
   sFile.ToLower();

   if (!sFile.IsNull()) {
     // split string in tokens (libs)
     TObjArray* tokens_list = sFile.Tokenize("/");
     tokens_list->SetOwner(kTRUE);
     TIter next_str(tokens_list);
     TObjString* token = NULL;
     while ((token=(TObjString*)next_str())) {
       TString token_str = token->GetString();
       if ( token_str.BeginsWith("pass") ) { pass = token_str; break; }
       }
     delete tokens_list;
     }

   return pass;
 }


inline TString GetFileFromPath ( const char* file_path = "" ) {
TString file (file_path);
TString file_name ("");
TObjArray* token_list = file.Tokenize("/");
token_list->SetOwner(kTRUE);

if ( token_list->GetEntries() > 0 )
  { file_name = ((TObjString*)token_list->At(token_list->GetLast()))->GetString(); }

delete token_list;
return file_name;
}


inline bool SaveManager ( const char* file_name) {
   AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
   if ( !mgr ) { ::Error ( "SaveManager", "No analysis manager to connect to." ); return kFALSE; }

   TFile pOutFile (file_name,"RECREATE");
   if ( ! pOutFile.cd() ) { ::Error ( "SaveManager", "Could not use the new created file" ); return kFALSE; }
   Int_t written_bytes = mgr->Write();
   pOutFile.Close();
   if (written_bytes == 0 ) { ::Error ( "SaveManager", "0 bytes written saving manager to file" ); return kFALSE; }
   return kTRUE;
   }

inline Double_t JetPtRho(const AliEmcalJet* jet, Double_t rho) {
  return jet->Pt() - jet->Area() * rho;
  }

} // namespace AliAnalysisTaskEmcalJetCDF_NS
} // namespace EMCALJetTasks
} // namespace PWGJE


#endif // end of #ifndef ALIANALYSISTASKEMCALJETCDF_H

// kate: indent-mode none; indent-width 2; replace-tabs on;