AliAnalysisTaskSELc2V0bachelor.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKSELC2V0BACHELOR_H
#define ALIANALYSISTASKSELC2V0BACHELOR_H
/**************************************************************************
 * Copyright(c) 1998-2009, 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.                  *
 **************************************************************************/

/* $Id$ */ 

#include "TROOT.h"
#include "TSystem.h"
#include "TVector.h"

#include "AliAnalysisTaskSE.h"
#include "AliAODEvent.h"
#include "AliPID.h"
#include "AliAODTrack.h"
#include "AliRDHFCutsLctoV0.h"
#include "AliNormalizationCounter.h"
#include <vector>


class TH1F;
class TClonesArray;
class AliAODRecoCascade;

class AliAnalysisTaskSELc2V0bachelor : public AliAnalysisTaskSE 
{
  
 public:
  
  AliAnalysisTaskSELc2V0bachelor();
  AliAnalysisTaskSELc2V0bachelor(const Char_t* name, AliRDHFCutsLctoV0* cuts,
         Bool_t useOnTheFly=kFALSE, Bool_t writeVariableTree=kTRUE, Bool_t additionalChecks=kFALSE, Bool_t trackRotation=kFALSE, Bool_t useTPCpid=kFALSE, Char_t sign=2, Bool_t checkOrigin=kFALSE);
  virtual ~AliAnalysisTaskSELc2V0bachelor();

  virtual void UserCreateOutputObjects();
  virtual void Init();
  virtual void LocalInit() {Init();}
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *option);
 
  void FillLc2pK0Sspectrum(AliAODRecoCascadeHF *part, Int_t isLc,
         Int_t &nSelectedAnal, AliRDHFCutsLctoV0 *cutsAnal,
         TClonesArray *mcArray, Int_t originLc);

  void MakeAnalysisForLc2prK0S(AliAODEvent* aodEvent,TClonesArray *arrayLctopK0S,
             TClonesArray *mcArray,
             Int_t &nSelectedAnal, AliRDHFCutsLctoV0 *cutsAnal);
 
  void MakeSingleAnalysisForSystK0SP(AliAODEvent* aodEvent,TClonesArray *mcArray, 
      AliRDHFCutsLctoV0 *cutsAnal);

  void SetGenerateBGEventFromTracks(Int_t a){fGenerateBGEventFromTracks=a;}
  Int_t GetPoolIndex(Double_t zvert, Double_t mult);
  void DoEventMixing(AliAODEvent* aodEvent,TClonesArray *mcArray, AliRDHFCutsLctoV0 *cutsAnal);
  void FillMixedBackground(std::vector<TVector * > mixTypePVars, AliAODEvent *aod, AliRDHFCutsLctoV0 *cutsAnal);
  void DoRotationFromTrack(AliAODEvent* aodEvent,TClonesArray *mcArray, AliRDHFCutsLctoV0 *cutsAnal);

  void SetMC(Bool_t theMCon) {fUseMCInfo = theMCon;}
  Bool_t GetMC() const {return fUseMCInfo;}

  void SetAdditionalChecks(Bool_t additionalChecks) {fAdditionalChecks = additionalChecks;}
  Bool_t GetAdditionalChecks() const {return fAdditionalChecks;}

  void SetFillSubSampleHist(Bool_t subChecks) {fFillSubSampleHist = subChecks;}
  Bool_t GetFillSubSampleHist() const {return fFillSubSampleHist;}

  void FillArmPodDistribution(AliAODRecoDecay *vZero,TString histoTitle, Bool_t isCandidateSelectedCuts, Bool_t isBachelorID);

  void SetUseOnTheFlyV0(Bool_t a) { fUseOnTheFlyV0=a; }
  Bool_t GetUseOnTheFlyV0() { return fUseOnTheFlyV0; }

  Int_t MatchToMClabelC(AliAODRecoCascadeHF *candidate,TClonesArray *mcArray);


  void SetNRotations(Int_t nRot=9) { fNRotations=nRot; }
  Int_t GetNRotations() { return fNRotations; }

  void SetPtMinToFillTheTree(Double_t pTmin=  0.) { fPtMinToFillTheTree=pTmin; }
  void SetPtMaxToFillTheTree(Double_t pTmax=999.) { fPtMaxToFillTheTree=pTmax; }
  Double_t GetPtMinToFillTheTree() { return fPtMinToFillTheTree; }
  Double_t GetPtMaxToFillTheTree() { return fPtMaxToFillTheTree; }

  void SetMinAngleForRot(Double_t min=5.*TMath::Pi()/6.) { fMinAngleForRot=min; }
  void SetMaxAngleForRot(Double_t max=7.*TMath::Pi()/6.) { fMaxAngleForRot=max; }
  Double_t GetMinAngleForRot() { return fMinAngleForRot; }
  Double_t GetMaxAngleForRot() { return fMaxAngleForRot; }

  void SetUseTPCPIDtoFillTree(Bool_t a) {fUseTPCPIDtoFillTree=a;}
  Bool_t GetUseTPCPIDtoFillTree() const {return fUseTPCPIDtoFillTree;}

  void SetSign(Char_t sign) {fSign = sign;}
  Char_t GetSign() const {return fSign;}

  void SetCheckOrigin(Bool_t origin) {fCheckOrigin = origin;}
  Bool_t GetCheckOrigin() const {return fCheckOrigin;}


  void ReconstructSecVtx(Bool_t dummy=kTRUE) {fReconstructSecVtx=dummy;}
  Bool_t GetReconstructSecVtx() const {return fReconstructSecVtx;}

  void SetDoSingleAnalysisForSystK0SP(Int_t a) {fDoSingleAnalysisForSystK0SP=a;}
  Int_t GetDoSingleAnalysisForSystK0SP() {return fDoSingleAnalysisForSystK0SP;}

  void SetAODMismatchProtection(Int_t opt=1) {fAODProtection=opt;}

 private:
  
  void CheckEventSelection(AliAODEvent *aodEvent);
  void CheckEventSelectionWithCandidates(AliAODEvent *aodEvent);
  void CheckCandidatesAtDifferentLevels(AliAODRecoCascadeHF *part,AliRDHFCutsLctoV0* cutsAnal);
  void FillTheTree(AliAODRecoCascadeHF *part, AliRDHFCutsLctoV0 *cutsAnal, TClonesArray *mcArray, Int_t isLc, Int_t originLc);
  void DefineTreeVariables();

  Int_t MatchToMC(AliAODRecoCascadeHF *lc2bacV0,
      Int_t *pdgDgLc2bacV0, Int_t *pdgDgV0,
      TClonesArray *mcArray);

  Int_t SearchLcDaughter(TClonesArray *arrayMC, Int_t iii);

  void DefineGeneralHistograms();
  void DefineK0SHistos();
  void DefineSignalHistosSeparatedPerOrigin();
  void FillAnalysisHistograms(AliAODRecoCascadeHF *part, AliRDHFCutsLctoV0 *cutsAnal, TString appendthis);
  void TrackRotation(AliRDHFCutsLctoV0 *cutsAnal, AliAODRecoCascadeHF *part, TString appendthis);

  AliAnalysisTaskSELc2V0bachelor(const AliAnalysisTaskSELc2V0bachelor &source);
  AliAnalysisTaskSELc2V0bachelor& operator=(const AliAnalysisTaskSELc2V0bachelor& source); 
  
  Double_t Det(Double_t a00,Double_t a01,
         Double_t a10,Double_t a11) const;
  Double_t Det(Double_t a00,Double_t a01,Double_t a02,
         Double_t a10,Double_t a11,Double_t a12,
         Double_t a20,Double_t a21,Double_t a22) const;
  Double_t PropagateToDCA(AliAODv0 *v, AliAODTrack *bachelor, Double_t b,
        Double_t &xVtxLc, Double_t &yVtxLc, Double_t &zVtxLc,
        Double_t &pxVtxLc, Double_t &pyVtxLc, Double_t &pzVtxLc);

  Double_t GetAlpha(Double_t xyz[3],Double_t pxpypz[3]);

  Int_t SearchForCommonMother(TClonesArray *mcArray,
            Int_t dgLabels[10],Int_t ndg,
            Int_t &ndgCk, Int_t *pdgDg, Int_t &labelMother, Int_t &nDauCand) const;

  Bool_t fUseMCInfo;          
  TList *fOutput;             
  TList *fOutputAll;          
  TList *fOutputPIDBach;      

  TH1F *fCEvents;                    
  Int_t fEventCounter; 
  AliNormalizationCounter *fCounter; 
  AliRDHFCutsLctoV0 *fAnalCuts;      
  Bool_t fUseOnTheFlyV0;             
  Int_t     fAODProtection;       
  Bool_t fIsEventSelected;           

  Bool_t    fWriteVariableTree;       
  TTree    *fVariablesTree;           
  Float_t *fCandidateVariables;       
  AliAODVertex *fVtx1;                
  Float_t fBzkG;                      
  Bool_t fAdditionalChecks;           
  Bool_t fFillSubSampleHist;           

  Bool_t fTrackRotation;              
  TList *fOutputPIDBachTR;            

  Double_t fMinAngleForRot; 
  Double_t fMaxAngleForRot; 
  Double_t fMinMass;        
  Double_t fMaxMass;        
  Int_t fNRotations;        
  Double_t fPtMinToFillTheTree;
  Double_t fPtMaxToFillTheTree;
  Bool_t fUseTPCPIDtoFillTree;
  Char_t fSign;
  Bool_t fCheckOrigin;
  Bool_t fReconstructSecVtx;

  Int_t fDoSingleAnalysisForSystK0SP; 

  // Mixed event (track level)
  Int_t fGenerateBGEventFromTracks; 
  Int_t  fNumberOfEventsForMixing; 
  Int_t fNzVtxBins;               
  Double_t fZvtxBins[100];            // [fNzVtxBinsDim]
  Int_t fNCentBins;               
  Double_t fCentBins[100];            // [fNCentBinsDim]
  Int_t  fNOfPools; 
  Int_t fPoolIndex; 
  std::vector<Int_t> fNextResVec; 
  std::vector<Bool_t> fReservoirsReady; 
  std::vector<std::vector< std::vector< TVector * > > > fReservoirP; 

  ClassDef(AliAnalysisTaskSELc2V0bachelor,14); 
};

#endif