[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliNormalizationCounter.h

#ifndef ALINORMALIZATIONCOUNTER_H
#define ALINORMALIZATIONCOUNTER_H

/**************************************************************************
 * Copyright(c) 1998-2008, 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$ */ 

//*************************************************************************
// Class AliNormalizationCounter
// Class to store the informations relevant for the normalization in the 
// barrel for each run
// Authors: G. Ortona, ortona@to.infn.it
// D. Caffarri, davide.caffarri@pd.to.infn.it
// with many thanks to P. Pillot
/////////////////////////////////////////////////////////////

#include <TROOT.h>
#include <TSystem.h>
#include <TNtuple.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TH1D.h>
#include <AliESDEvent.h>
#include <AliESDtrack.h>
#include <AliAODTrack.h>
#include <AliAODEvent.h>
#include <AliVParticle.h>
#include "AliAnalysisTaskSE.h"
#include "AliCounterCollection.h"
#include "AliAnalysisDataSlot.h"
#include "AliAnalysisDataContainer.h"
#include "AliRDHFCuts.h"
//#include "AliAnalysisVertexingHF.h"

class AliNormalizationCounter : public TNamed
{
 public:

  AliNormalizationCounter();
  AliNormalizationCounter(const char *name);
  virtual ~AliNormalizationCounter();
  Long64_t Merge(TCollection* list);

  AliCounterCollection* GetCounter(){return &fCounters;}
  void Init();
  void Add(const AliNormalizationCounter*);
  void SetESD(Bool_t flag){fESD=flag;}
  void SetStudyMultiplicity(Bool_t flag, Float_t etaRange){ fMultiplicity=flag; fMultiplicityEtaRange=etaRange; }
  void StoreEvent(AliVEvent*,AliRDHFCuts *,Bool_t mc=kFALSE, Int_t multiplicity=-9999);
  void StoreCandidates(AliVEvent*, Int_t nCand=0,Bool_t flagFilter=kTRUE);
  TH1D* DrawAgainstRuns(TString candle="candid(filter)",Bool_t drawHist=kTRUE);
  TH1D* DrawRatio(TString candle1="candid(filter)",TString candle2="triggered");
  void PrintRubrics();
  Double_t GetSum(TString candle="triggered");
  TH2F* GetHist(Bool_t filtercuts=kTRUE,Bool_t spdtracklets=kTRUE,Bool_t drawHist=kFALSE);
  Double_t GetNEventsForNorm();
  Double_t GetNEventsForNorm(Int_t runnumber);
  Bool_t GetStudyMultiplicity(){ return fMultiplicity; }
  Float_t GetStudyMultplicityEtaRange() { return fMultiplicityEtaRange; }
  Double_t GetNEventsForNorm(Int_t minmultiplicity, Int_t maxmultiplicity);
  TH1D* DrawNEventsForNorm(Bool_t drawRatio=kFALSE);

 private:
  AliNormalizationCounter(const AliNormalizationCounter &source);
  AliNormalizationCounter& operator=(const AliNormalizationCounter& source);
  Int_t Multiplicity(AliVEvent* event);
  AliCounterCollection fCounters; //internal counter
  Bool_t fESD; //flag for ESD vs AOD
  Bool_t fMultiplicity; //flag for multiplicity
  Float_t fMultiplicityEtaRange;
  TH2F *fHistTrackFilterEvMult; //hist to store no of filter candidates vs no of tracks in the event 
  TH2F *fHistTrackAnaEvMult;//hist to store no of analysis candidates vs no of tracks in the event 
  TH2F *fHistTrackFilterSpdMult; //hist to store no of filter candidates vs  SPD multiplicity 
  TH2F *fHistTrackAnaSpdMult;//hist to store no of analysis candidates vs SPD multiplicity 

  ClassDef(AliNormalizationCounter,6);

};
#endif
Commit	Line	Data
8eea8388	1	#ifndef ALINORMALIZATIONCOUNTER_H
	2	#define ALINORMALIZATIONCOUNTER_H
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Author: The ALICE Off-line Project. *
	8	* Contributors are mentioned in the code where appropriate. *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	/* $Id$ */
	20
	21	//*************************************************************************
	22	// Class AliNormalizationCounter
	23	// Class to store the informations relevant for the normalization in the
	24	// barrel for each run
	25	// Authors: G. Ortona, ortona@to.infn.it
	26	// D. Caffarri, davide.caffarri@pd.to.infn.it
	27	// with many thanks to P. Pillot
	28	/////////////////////////////////////////////////////////////
	29
	30	#include <TROOT.h>
	31	#include <TSystem.h>
	32	#include <TNtuple.h>
	33	#include <TH1F.h>
	34	#include <TH2F.h>
	35	#include <TH1D.h>
	36	#include <AliESDEvent.h>
	37	#include <AliESDtrack.h>
	38	#include <AliAODTrack.h>
	39	#include <AliAODEvent.h>
	40	#include <AliVParticle.h>
	41	#include "AliAnalysisTaskSE.h"
	42	#include "AliCounterCollection.h"
	43	#include "AliAnalysisDataSlot.h"
	44	#include "AliAnalysisDataContainer.h"
	45	#include "AliRDHFCuts.h"
	46	//#include "AliAnalysisVertexingHF.h"
	47
	48	class AliNormalizationCounter : public TNamed
	49	{
	50	public:
	51
	52	AliNormalizationCounter();
	53	AliNormalizationCounter(const char *name);
	54	virtual ~AliNormalizationCounter();
	55	Long64_t Merge(TCollection* list);
	56
	57	AliCounterCollection* GetCounter(){return &fCounters;}
	58	void Init();
	59	void Add(const AliNormalizationCounter*);
	60	void SetESD(Bool_t flag){fESD=flag;}
	61	void SetStudyMultiplicity(Bool_t flag, Float_t etaRange){ fMultiplicity=flag; fMultiplicityEtaRange=etaRange; }
71d2489f	62	void StoreEvent(AliVEvent,AliRDHFCuts ,Bool_t mc=kFALSE, Int_t multiplicity=-9999);
8eea8388	63	void StoreCandidates(AliVEvent*, Int_t nCand=0,Bool_t flagFilter=kTRUE);
	64	TH1D* DrawAgainstRuns(TString candle="candid(filter)",Bool_t drawHist=kTRUE);
	65	TH1D* DrawRatio(TString candle1="candid(filter)",TString candle2="triggered");
	66	void PrintRubrics();
	67	Double_t GetSum(TString candle="triggered");
	68	TH2F* GetHist(Bool_t filtercuts=kTRUE,Bool_t spdtracklets=kTRUE,Bool_t drawHist=kFALSE);
	69	Double_t GetNEventsForNorm();
	70	Double_t GetNEventsForNorm(Int_t runnumber);
	71	Bool_t GetStudyMultiplicity(){ return fMultiplicity; }
	72	Float_t GetStudyMultplicityEtaRange() { return fMultiplicityEtaRange; }
	73	Double_t GetNEventsForNorm(Int_t minmultiplicity, Int_t maxmultiplicity);
	74	TH1D* DrawNEventsForNorm(Bool_t drawRatio=kFALSE);
	75
	76	private:
	77	AliNormalizationCounter(const AliNormalizationCounter &source);
	78	AliNormalizationCounter& operator=(const AliNormalizationCounter& source);
	79	Int_t Multiplicity(AliVEvent* event);
	80	AliCounterCollection fCounters; //internal counter
	81	Bool_t fESD; //flag for ESD vs AOD
	82	Bool_t fMultiplicity; //flag for multiplicity
	83	Float_t fMultiplicityEtaRange;
	84	TH2F *fHistTrackFilterEvMult; //hist to store no of filter candidates vs no of tracks in the event
	85	TH2F *fHistTrackAnaEvMult;//hist to store no of analysis candidates vs no of tracks in the event
	86	TH2F *fHistTrackFilterSpdMult; //hist to store no of filter candidates vs SPD multiplicity
	87	TH2F *fHistTrackAnaSpdMult;//hist to store no of analysis candidates vs SPD multiplicity
	88
	89	ClassDef(AliNormalizationCounter,6);
	90
	91	};
	92	#endif