[u/mrichter/AliRoot.git] / PWG1 / Centrality / AliMultiplicityCorrelations.h

//-*- Mode: C++ -*-

// $Id: AliMultiplicityCorrelations.h  $
#ifndef ALIMULTIPLICITYCORRELATIONS_H
#define ALIMULTIPLICITYCORRELATIONS_H


/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */
 
// Correlation plots for multiplicity studies
// Authors: Jochen Thaeder <jochen@thaeder.de>

#include "AliLog.h"

#include "AliESDtrackCuts.h"
#include "AliESDEvent.h"
#include "AliESDVZERO.h"
#include "AliESDZDC.h"
#include "AliMultiplicity.h"
#include "TList.h"

class TH1;

class AliMultiplicityCorrelations : public TNamed {
public:
  
  /*
   * ---------------------------------------------------------------------------------
   *                            Constructor / Destructor
   * ---------------------------------------------------------------------------------
   */

  /** Default Constructor */
  AliMultiplicityCorrelations();
  
  /** Constructor */
  AliMultiplicityCorrelations(Char_t* name, Char_t* title);
  
  /** Destructor */
  ~AliMultiplicityCorrelations();

  /*
   * ---------------------------------------------------------------------------------
   *                         Initialize / Setup / Reset - public
   * ---------------------------------------------------------------------------------
   */

  /** Initialize class and members */
  Int_t Initialize() { return Initialize(""); }

  /** Initialize class and members */
  Int_t Initialize( const Char_t* listName );

  /*
   * ---------------------------------------------------------------------------------
   *                                Setter - public
   * ---------------------------------------------------------------------------------
   */

  void SetIsMC() { fIsMC = kTRUE; }

  /** Clean event sample */
  void SetCleanSample(Float_t min, Float_t max) { fCleanSample = kTRUE; fCleanMinKeep = min; fCleanMaxKeep = max; }

  /** Set ESD track cuts */
  void SetESDTrackCuts(AliESDtrackCuts *cuts) { fESDTrackCuts  = cuts; }
  void SetESDTrackCuts2(AliESDtrackCuts *cuts) { fESDTrackCuts2 = cuts; }

  /** Set SPD clusters from inner and outer layer */
  void SetSPDClusters(Float_t inner, Float_t outer) { fSpdNClustersInner = inner; fSpdNClustersOuter = outer; }

  /** Set Binning of VZERO */
  void SetBinningVzero(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
    fVzeroBinning = i; fVzeroBinningMin = f1; fVzeroBinningMax = f2;
  }

  /** Set Binning of TPC */
  void SetBinningTpc(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
    fTpcBinning = i; fTpcBinningMin = f1; fTpcBinningMax = f2;
  }

  /** Set Binning of ZDC */
  void SetBinningZdc(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
    fZdcBinning = i; fZdcBinningMin = f1; fZdcBinningMax = f2;
  }

  /** Set Binning of ZEM */
  void SetBinningZem(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
    fZemBinning = i; fZemBinningMin = f1; fZemBinningMax = f2;
  }

  /** Set Binning of SPD */
  void SetBinningSpd(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
    fSpdBinning = i; fSpdBinningMin = f1; fSpdBinningMax = f2;
  }

  /** Enable / Disable detectors */
  void SetProcessSPD(Bool_t b = kTRUE)  { fProcessSPD = b; }
  void SetProcessTPC(Bool_t b = kTRUE)  { fProcessTPC = b; }
  void SetProcessZDC(Bool_t b = kTRUE)  { fProcessZDC = b; }
  void SetProcessVZERO(Bool_t b = kTRUE){ fProcessVZERO = b; }

  /*
   * ---------------------------------------------------------------------------------
   *                                 Getter - public
   * ---------------------------------------------------------------------------------
   */

  /** Get List of histograms */
  TList* GetHistList() const { return fHistList; }

  Int_t GetNTracks() { return fEsdTracksA; }
  Int_t GetNTracksTPC() { return fTpcTracksA; }
  Float_t GetVZEROA() { return fVzeroMultA; }
  Float_t GetVZEROC() { return fVzeroMultC; }
  Float_t GetVZEROCorr() { return fVzeroMult; }

  /*
   * ---------------------------------------------------------------------------------
   *                             Process - public
   * ---------------------------------------------------------------------------------
   */

  /** Process current event */
  Int_t ProcessEvent( AliESDEvent *esd );

  ///////////////////////////////////////////////////////////////////////////////////
  
  /** Corrected VZERO amplitude*/
  Float_t GetCorrVZERO(Float_t &v0CorrResc);

  /** Corrected SPD amplitude*/
  Float_t GetCorrSPD2(Float_t spd2raw,Float_t zv);

 private:
 
  /** copy constructor prohibited */
  AliMultiplicityCorrelations(const AliMultiplicityCorrelations&);
  
  /** assignment operator prohibited */
  AliMultiplicityCorrelations& operator=(const AliMultiplicityCorrelations&);

  /*
   * ---------------------------------------------------------------------------------
   *                         Initialize / Setup / Reset - private
   * ---------------------------------------------------------------------------------
   */

  /** Add esd object
   * param esd Ptr to AliESDEvent
   * return kTRUE if AliESDEvent and Vertex present
   */
  Bool_t AddESDEvent( AliESDEvent* esd );

  /** Setup histograms */
  Int_t SetupHistograms();

  /** Setup VZERO histograms */
  Int_t SetupVZERO();

  /** Setup ZDC histograms */
  Int_t SetupZDC();

  /** Setup TPC histograms */
  Int_t SetupTPC();

  /** Setup correlation histograms */
  Int_t SetupCorrelations();
  
  /** Setup SPD histograms */
  Int_t SetupSPD();

  /*
   * ---------------------------------------------------------------------------------
   *                             Process - private
   * ---------------------------------------------------------------------------------
   */

  /** Process current event - TPC */
  Int_t ProcessTPC();

  /** Process current event - SPD */
  Int_t ProcessSPD();
  
  /** Process current event - VZERO */
  Int_t ProcessVZERO();

  /** Process current event - ZDC and correlations */
  Int_t ProcessZDC();
  
  /*
   * ---------------------------------------------------------------------------------
   *                             Members - private
   * ---------------------------------------------------------------------------------
   */

  TList           *fHistList;             //  List of histograms

  Bool_t           fIsMC;                 //  If it is MC 

  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 

  AliESDEvent     *fESDEvent;             //! Ptr to AliESDEvent
  AliESDZDC       *fESDZDC;               //! Ptr to ZDC object in AliESDEvent 
  AliESDVZERO     *fESDVZERO;             //! Ptr to VZERO object in AliESDEvent
  AliMultiplicity *fESDMultiplicity;      //! Ptr to AliMultiplicity in AliESDEvent
  AliESDtrackCuts *fESDTrackCuts;         //! Ptr to AliESDtrackCuts
  AliESDtrackCuts *fESDTrackCuts2;        //! Ptr to AliESDtrackCuts 2
  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 

  Bool_t           fCleanSample;          //  Enables 'grass' cleaning
  Float_t          fCleanMinKeep;         //  Min of kept region
  Float_t          fCleanMaxKeep;         //  Max of kept region

  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 

  Int_t            fRunNo;                //  RunNo for corrections
  Int_t            fCurrentRunNo;         //  Current RunNo

  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 

  Bool_t           fProcessTPC;           //  Process TPC information
  Bool_t           fProcessSPD;           //  Process SPD information
  Bool_t           fProcessVZERO;         //  Process VZERO information
  Bool_t           fProcessZDC;           //  Process ZDC information

  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

  Int_t            fEsdTracks;            //  N ESD tracks
  Int_t            fEsdTracksA;           //  N ESD tracks accepted
  Int_t            fTpcTracks;            //  N TPC tracks
  Int_t            fTpcTracksA;           //  N TPC tracks accepted

  Float_t          fVzeroMult;            //  VZERO multiplicity
  Float_t          fVzeroMultA;           //  VZERO A multiplicity
  Float_t          fVzeroMultC;           //  VZERO C multiplicity

  Float_t          fSpdNClusters;         //  Spd N clusters
  Float_t          fSpdNClustersInner;    //  Spd N clusters Inner 
  Float_t          fSpdNClustersOuter;    //  Spd N clusters Outer

  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 

  /** Binnning VZERO */
  Int_t   fVzeroBinning;
  Float_t fVzeroBinningMin;
  Float_t fVzeroBinningMax;

  /** Binnning TPC */
  Int_t   fTpcBinning;
  Float_t fTpcBinningMin;
  Float_t fTpcBinningMax;

  /** Binnning ZDC */
  Int_t   fZdcBinning;
  Float_t fZdcBinningMin;
  Float_t fZdcBinningMax;

  /** Binnning ZEM */
  Int_t   fZemBinning;
  Float_t fZemBinningMin;
  Float_t fZemBinningMax;

  /** Binnning SPD */
  Int_t   fSpdBinning;
  Float_t fSpdBinningMin;
  Float_t fSpdBinningMax;
  
  ClassDef(AliMultiplicityCorrelations, 3);
};
#endif
Commit	Line	Data
44a84424	1	//-- Mode: C++ --
	2
	3	// $Id: AliMultiplicityCorrelations.h $
	4	#ifndef ALIMULTIPLICITYCORRELATIONS_H
	5	#define ALIMULTIPLICITYCORRELATIONS_H
	6
	7
	8	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	9	* See cxx source for full Copyright notice */
	10
	11	// Correlation plots for multiplicity studies
	12	// Authors: Jochen Thaeder <jochen@thaeder.de>
	13
	14	#include "AliLog.h"
	15
	16	#include "AliESDtrackCuts.h"
	17	#include "AliESDEvent.h"
	18	#include "AliESDVZERO.h"
	19	#include "AliESDZDC.h"
	20	#include "AliMultiplicity.h"
	21	#include "TList.h"
	22
	23	class TH1;
	24
	25	class AliMultiplicityCorrelations : public TNamed {
	26	public:
	27
	28	/*
	29	* ---------------------------------------------------------------------------------
	30	* Constructor / Destructor
	31	* ---------------------------------------------------------------------------------
	32	*/
	33
	34	/** Default Constructor */
	35	AliMultiplicityCorrelations();
	36
	37	/** Constructor */
	38	AliMultiplicityCorrelations(Char_t* name, Char_t* title);
	39
	40	/** Destructor */
	41	~AliMultiplicityCorrelations();
	42
	43	/*
	44	* ---------------------------------------------------------------------------------
	45	* Initialize / Setup / Reset - public
	46	* ---------------------------------------------------------------------------------
	47	*/
	48
	49	/** Initialize class and members */
	50	Int_t Initialize() { return Initialize(""); }
	51
	52	/** Initialize class and members */
	53	Int_t Initialize( const Char_t* listName );
	54
	55	/*
	56	* ---------------------------------------------------------------------------------
	57	* Setter - public
	58	* ---------------------------------------------------------------------------------
	59	*/
	60
	61	void SetIsMC() { fIsMC = kTRUE; }
	62
	63	/** Clean event sample */
	64	void SetCleanSample(Float_t min, Float_t max) { fCleanSample = kTRUE; fCleanMinKeep = min; fCleanMaxKeep = max; }
65
66	/** Set ESD track cuts */
67	void SetESDTrackCuts(AliESDtrackCuts *cuts) { fESDTrackCuts = cuts; }
68	void SetESDTrackCuts2(AliESDtrackCuts *cuts) { fESDTrackCuts2 = cuts; }
69
70	/** Set SPD clusters from inner and outer layer */
71	void SetSPDClusters(Float_t inner, Float_t outer) { fSpdNClustersInner = inner; fSpdNClustersOuter = outer; }
72
73	/** Set Binning of VZERO */
74	void SetBinningVzero(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
75	fVzeroBinning = i; fVzeroBinningMin = f1; fVzeroBinningMax = f2;
76	}
77
78	/** Set Binning of TPC */
79	void SetBinningTpc(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
80	fTpcBinning = i; fTpcBinningMin = f1; fTpcBinningMax = f2;
81	}
82
83	/** Set Binning of ZDC */
84	void SetBinningZdc(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
85	fZdcBinning = i; fZdcBinningMin = f1; fZdcBinningMax = f2;
86	}
87
88	/** Set Binning of ZEM */
89	void SetBinningZem(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
90	fZemBinning = i; fZemBinningMin = f1; fZemBinningMax = f2;
91	}
92
93	/** Set Binning of SPD */
94	void SetBinningSpd(Int_t i=1, Float_t f1=0., Float_t f2=1.) {
95	fSpdBinning = i; fSpdBinningMin = f1; fSpdBinningMax = f2;
96	}
97
98	/** Enable / Disable detectors */
99	void SetProcessSPD(Bool_t b = kTRUE) { fProcessSPD = b; }
100	void SetProcessTPC(Bool_t b = kTRUE) { fProcessTPC = b; }
101	void SetProcessZDC(Bool_t b = kTRUE) { fProcessZDC = b; }
102	void SetProcessVZERO(Bool_t b = kTRUE){ fProcessVZERO = b; }
103
104	/*
105	* ---------------------------------------------------------------------------------
106	* Getter - public
107	* ---------------------------------------------------------------------------------
108	*/
109
110	/** Get List of histograms */
111	TList* GetHistList() const { return fHistList; }
112
113	Int_t GetNTracks() { return fEsdTracksA; }
114	Int_t GetNTracksTPC() { return fTpcTracksA; }
115	Float_t GetVZEROA() { return fVzeroMultA; }
116	Float_t GetVZEROC() { return fVzeroMultC; }
117	Float_t GetVZEROCorr() { return fVzeroMult; }
118
119	/*
120	* ---------------------------------------------------------------------------------
121	* Process - public
122	* ---------------------------------------------------------------------------------
123	*/
124
125	/** Process current event */
126	Int_t ProcessEvent( AliESDEvent *esd );
127
128	///////////////////////////////////////////////////////////////////////////////////
129
130	/** Corrected VZERO amplitude*/
131	Float_t GetCorrVZERO(Float_t &v0CorrResc);
132
133	/** Corrected SPD amplitude*/
134	Float_t GetCorrSPD2(Float_t spd2raw,Float_t zv);
135
136	private:
137
138	/** copy constructor prohibited */
139	AliMultiplicityCorrelations(const AliMultiplicityCorrelations&);
140
141	/** assignment operator prohibited */
142	AliMultiplicityCorrelations& operator=(const AliMultiplicityCorrelations&);
143
144	/*
145	* ---------------------------------------------------------------------------------
146	* Initialize / Setup / Reset - private
147	* ---------------------------------------------------------------------------------
148	*/
149
150	/** Add esd object
151	* param esd Ptr to AliESDEvent
152	* return kTRUE if AliESDEvent and Vertex present
153	*/
154	Bool_t AddESDEvent( AliESDEvent* esd );
155
156	/** Setup histograms */
157	Int_t SetupHistograms();
158
159	/** Setup VZERO histograms */
160	Int_t SetupVZERO();
161
162	/** Setup ZDC histograms */
163	Int_t SetupZDC();
164
165	/** Setup TPC histograms */
166	Int_t SetupTPC();
167
168	/** Setup correlation histograms */
169	Int_t SetupCorrelations();
170
171	/** Setup SPD histograms */
172	Int_t SetupSPD();
173
174	/*
175	* ---------------------------------------------------------------------------------
176	* Process - private
177	* ---------------------------------------------------------------------------------
178	*/
179
180	/** Process current event - TPC */
181	Int_t ProcessTPC();
182
183	/** Process current event - SPD */
184	Int_t ProcessSPD();
185
186	/** Process current event - VZERO */
187	Int_t ProcessVZERO();
188
189	/** Process current event - ZDC and correlations */
190	Int_t ProcessZDC();
191
192	/*
193	* ---------------------------------------------------------------------------------
194	* Members - private
195	* ---------------------------------------------------------------------------------
196	*/
197
198	TList *fHistList; // List of histograms
199
200	Bool_t fIsMC; // If it is MC
201
202	// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
203
204	AliESDEvent *fESDEvent; //! Ptr to AliESDEvent
205	AliESDZDC *fESDZDC; //! Ptr to ZDC object in AliESDEvent
206	AliESDVZERO *fESDVZERO; //! Ptr to VZERO object in AliESDEvent
207	AliMultiplicity *fESDMultiplicity; //! Ptr to AliMultiplicity in AliESDEvent
208	AliESDtrackCuts *fESDTrackCuts; //! Ptr to AliESDtrackCuts
209	AliESDtrackCuts *fESDTrackCuts2; //! Ptr to AliESDtrackCuts 2
210	// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
211
212	Bool_t fCleanSample; // Enables 'grass' cleaning
213	Float_t fCleanMinKeep; // Min of kept region
214	Float_t fCleanMaxKeep; // Max of kept region
215
216	// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
217
218	Int_t fRunNo; // RunNo for corrections
219	Int_t fCurrentRunNo; // Current RunNo
220
221	// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
222
223	Bool_t fProcessTPC; // Process TPC information
224	Bool_t fProcessSPD; // Process SPD information
225	Bool_t fProcessVZERO; // Process VZERO information
226	Bool_t fProcessZDC; // Process ZDC information
227
228	// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
229
230	Int_t fEsdTracks; // N ESD tracks
231	Int_t fEsdTracksA; // N ESD tracks accepted
232	Int_t fTpcTracks; // N TPC tracks
233	Int_t fTpcTracksA; // N TPC tracks accepted
234
235	Float_t fVzeroMult; // VZERO multiplicity
236	Float_t fVzeroMultA; // VZERO A multiplicity
237	Float_t fVzeroMultC; // VZERO C multiplicity
238
239	Float_t fSpdNClusters; // Spd N clusters
240	Float_t fSpdNClustersInner; // Spd N clusters Inner
241	Float_t fSpdNClustersOuter; // Spd N clusters Outer
242
243	// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
244
245	/** Binnning VZERO */
246	Int_t fVzeroBinning;
247	Float_t fVzeroBinningMin;
248	Float_t fVzeroBinningMax;
249
250	/** Binnning TPC */
251	Int_t fTpcBinning;
252	Float_t fTpcBinningMin;
253	Float_t fTpcBinningMax;
254
255	/** Binnning ZDC */
256	Int_t fZdcBinning;
257	Float_t fZdcBinningMin;
258	Float_t fZdcBinningMax;
259
260	/** Binnning ZEM */
261	Int_t fZemBinning;
262	Float_t fZemBinningMin;
263	Float_t fZemBinningMax;
264
265	/** Binnning SPD */
266	Int_t fSpdBinning;
267	Float_t fSpdBinningMin;
268	Float_t fSpdBinningMax;
269
270	ClassDef(AliMultiplicityCorrelations, 3);
271	};
272	#endif