[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliForwardMultiplicityDistribution.h

/**
 * @file   AliForwardMultiplicityDistribution.h
 * @author Christian Holm Christensen <cholm@master.hehi.nbi.dk>
 * @date   Thu Feb  7 01:02:42 2013
 * 
 * @brief  
 * 
 * 
 * @ingroup pwglf_forward_multdist
 */
#ifndef ALIFORWARDMULTIPLICITYDISTRIBUTION_H
#define ALIFORWARDMULTIPLICITYDISTRIBUTION_H
#include "AliBaseAODTask.h"

class TH2D;

/**
 * Task to do the multiplicity distibution
 * 
 * @ingroup pwglf_forward Tasks
 * @ingroup pwglf_forward_multdist
 * @todo Should not inherit from AliBasedNdetaTask 
 */
class AliForwardMultiplicityDistribution : public AliBaseAODTask
{
public:
  /**
   * Default Constructor
   */
  AliForwardMultiplicityDistribution();
  /**
   * Constructor
   */
  AliForwardMultiplicityDistribution(const char* name);
  /**
   * Destructor
   */
  virtual ~AliForwardMultiplicityDistribution(){}
  /**
   * Embedded Class begins here
   */
  struct Bin : public TNamed
  {
    /**
     * Default Constructor
     */
    Bin();
    /**
     * Constructor
     */
    Bin(Double_t etaLow, Double_t etaHigh);
    /**
     * Copy Constructor
     */    
    Bin(const Bin&){;}
    /**
     * Assignment operator
     */
    Bin& operator=(const Bin&){return*this;}
    /**
     * Destructor
     */    
    ~Bin(){}
    /**
     *  Define outputs of a single eta bin
     */
    virtual void CreateOutputObjectss(TList* cont,  Int_t max);
    /**
     * Process a single eta bin
     */
    virtual void Process(TH1D* dndetaForward, TH1D* dndetaCentral, TH1D* normForward,   TH1D* normCentral, Double_t VtxZ);
    Double_t fEtaLow;           // low eta limit 
    Double_t fEtaHigh;          // high eta limit 
    TH1D*    fHist;             // multiplicity distribution hist 
    TH1D*    fHistPlus05;       // mult. dist. hist scaled up with 5%
    TH1D*    fHistPlus075;      // mult. dist. hist scaled up with 7.5%
    TH1D*    fHistPlus10;       // mult. dist. hist scaled up with 10%
    TH1D*    fHistMinus05;      // mult. dist. hist scaled down with 5%
    TH1D*    fHistMinus075;     // mult. dist. hist scaled down with 7.5%
    TH1D*    fHistMinus10;      // mult. dist. hist scaled down with 10%
    TH1D*    fHistPlusSys;      // mult. dist. hist scaled up with the event uncertainty
    TH1D*    fHistMinusSys;     // mult. dist, hist scaled down with the event uncertainty
    TH2D*    fAcceptance;       // histogram showing the 'holes' in acceptance. 
                                // BinContent of 1 shows a hole, and BinContent of 10 shows data coverage
    TH2D*    fVtxZvsNdataBins;  // VtxZ vs. number of data acceptance bins (normalised to the eta range) 
    
    ClassDef(Bin,3);  // Manager of data 
  };
  /**
   * Create Output Objects
   */
  virtual Bool_t Book();
  /**
   * User Exec
   */
  Bool_t Event(AliAODEvent& aod);
  /**
   * Terminate
   */
  Bool_t Finalize() { return true; }
  /**
   * Set Centrality
   */
  void SetCentrality(Int_t low, Int_t high) { SetCentralityAxis(low, high); }
  /**
   * Set fNBins, multiplicity histos run from 0 to fNBins
   */
  void SetNBins(Int_t n){fNBins= n;}
  /** 
   * Add another eta bin to the task
   */
  void AddBin(Double_t etaLow, Double_t etaHigh){fBins.Add(new Bin(etaLow, etaHigh)); }
  /**
   *  Form name of eta bin
   */
  static const Char_t* FormBinName(Double_t etaLow, Double_t etaHigh);
protected:
  /**
   * Copy Constructor
   */ 
  AliForwardMultiplicityDistribution(const AliForwardMultiplicityDistribution&);
  /**
   * Assignment Operator
   */
  AliForwardMultiplicityDistribution& 
  operator=(const AliForwardMultiplicityDistribution&);

  TList  fBins;      // eta bin list
  Int_t  fNBins;     // multiplicity axis' runs from 0 to fNbins
  ClassDef(AliForwardMultiplicityDistribution, 3); 
};

#endif
// Local Variables:
//   mode: C++
// End:
Commit	Line	Data
33438b4c	1	/**
	2	* @file AliForwardMultiplicityDistribution.h
	3	* @author Christian Holm Christensen <cholm@master.hehi.nbi.dk>
	4	* @date Thu Feb 7 01:02:42 2013
	5	*
	6	* @brief
	7	*
	8	*
	9	* @ingroup pwglf_forward_multdist
	10	*/
ad7be237	11	#ifndef ALIFORWARDMULTIPLICITYDISTRIBUTION_H
ad7be237	12	#define ALIFORWARDMULTIPLICITYDISTRIBUTION_H
c8b1a7db	13	#include "AliBaseAODTask.h"
ad7be237	14
	15	class TH2D;
	16
	17	/**
	18	* Task to do the multiplicity distibution
	19	*
33438b4c	20	* @ingroup pwglf_forward Tasks
	21	* @ingroup pwglf_forward_multdist
	22	* @todo Should not inherit from AliBasedNdetaTask
ad7be237	23	*/
c8b1a7db	24	class AliForwardMultiplicityDistribution : public AliBaseAODTask
ad7be237	25	{
	26	public:
	27	/**
	28	* Default Constructor
	29	*/
	30	AliForwardMultiplicityDistribution();
	31	/**
	32	* Constructor
	33	*/
	34	AliForwardMultiplicityDistribution(const char* name);
ad7be237	35	/**
	36	* Destructor
	37	*/
	38	virtual ~AliForwardMultiplicityDistribution(){}
	39	/**
	40	* Embedded Class begins here
	41	*/
	42	struct Bin : public TNamed
	43	{
	44	/**
	45	* Default Constructor
	46	*/
	47	Bin();
	48	/**
	49	* Constructor
	50	*/
	51	Bin(Double_t etaLow, Double_t etaHigh);
	52	/**
	53	* Copy Constructor
	54	*/
ee83b849	55	Bin(const Bin&){;}
ad7be237	56	/**
	57	* Assignment operator
	58	*/
c8b1a7db	59	Bin& operator=(const Bin&){return*this;}
ad7be237	60	/**
	61	* Destructor
	62	*/
	63	~Bin(){}
	64	/**
	65	* Define outputs of a single eta bin
	66	*/
5934a3e3	67	virtual void CreateOutputObjectss(TList* cont, Int_t max);
ad7be237	68	/**
	69	* Process a single eta bin
	70	*/
	71	virtual void Process(TH1D* dndetaForward, TH1D* dndetaCentral, TH1D* normForward, TH1D* normCentral, Double_t VtxZ);
	72	Double_t fEtaLow; // low eta limit
	73	Double_t fEtaHigh; // high eta limit
	74	TH1D* fHist; // multiplicity distribution hist
c8b1a7db	75	TH1D* fHistPlus05; // mult. dist. hist scaled up with 5%
	76	TH1D* fHistPlus075; // mult. dist. hist scaled up with 7.5%
	77	TH1D* fHistPlus10; // mult. dist. hist scaled up with 10%
	78	TH1D* fHistMinus05; // mult. dist. hist scaled down with 5%
	79	TH1D* fHistMinus075; // mult. dist. hist scaled down with 7.5%
	80	TH1D* fHistMinus10; // mult. dist. hist scaled down with 10%
	81	TH1D* fHistPlusSys; // mult. dist. hist scaled up with the event uncertainty
	82	TH1D* fHistMinusSys; // mult. dist, hist scaled down with the event uncertainty
ad7be237	83	TH2D* fAcceptance; // histogram showing the 'holes' in acceptance.
	84	// BinContent of 1 shows a hole, and BinContent of 10 shows data coverage
	85	TH2D* fVtxZvsNdataBins; // VtxZ vs. number of data acceptance bins (normalised to the eta range)
	86
c8b1a7db	87	ClassDef(Bin,3); // Manager of data
ad7be237	88	};
	89	/**
	90	* Create Output Objects
	91	*/
c8b1a7db	92	virtual Bool_t Book();
ad7be237	93	/**
	94	* User Exec
	95	*/
c8b1a7db	96	Bool_t Event(AliAODEvent& aod);
ad7be237	97	/**
	98	* Terminate
	99	*/
c8b1a7db	100	Bool_t Finalize() { return true; }
ad7be237	101	/**
	102	* Set Centrality
	103	*/
c8b1a7db	104	void SetCentrality(Int_t low, Int_t high) { SetCentralityAxis(low, high); }
ad7be237	105	/**
	106	* Set fNBins, multiplicity histos run from 0 to fNBins
	107	*/
	108	void SetNBins(Int_t n){fNBins= n;}
ad7be237	109	/**
	110	* Add another eta bin to the task
	111	*/
	112	void AddBin(Double_t etaLow, Double_t etaHigh){fBins.Add(new Bin(etaLow, etaHigh)); }
	113	/**
	114	* Form name of eta bin
	115	*/
	116	static const Char_t* FormBinName(Double_t etaLow, Double_t etaHigh);
	117	protected:
c8b1a7db	118	/**
	119	* Copy Constructor
	120	*/
	121	AliForwardMultiplicityDistribution(const AliForwardMultiplicityDistribution&);
	122	/**
	123	* Assignment Operator
	124	*/
	125	AliForwardMultiplicityDistribution&
	126	operator=(const AliForwardMultiplicityDistribution&);
	127
ad7be237	128	TList fBins; // eta bin list
ad7be237	129	Int_t fNBins; // multiplicity axis' runs from 0 to fNbins
c8b1a7db	130	ClassDef(AliForwardMultiplicityDistribution, 3);
ad7be237	131	};
	132
	133	#endif
	134	// Local Variables:
	135	// mode: C++
	136	// End: