[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliFMDSharingFilter.h

#ifndef ALIROOT_PWG2_FORWARD_ALIFMDSHARINGFILTER_H
#define ALIROOT_PWG2_FORWARD_ALIFMDSHARINGFILTER_H
#include <TNamed.h>
#include <TH2.h>
#include <TList.h>
#include "AliForwardUtil.h"
class AliESDFMD;
class TAxis;
class TList;
class TH2;

/**
 * Class to do the sharing correction.  That is, a filter that merges 
 * adjacent strip signals presumably originating from a single particle 
 * that impinges on the detector in such a way that it deposite energy 
 * into two or more strips. 
 *
 * @par Input: 
 *    - AliESDFMD object  - from reconstruction
 *
 * @par Output: 
 *    - AliESDFMD object  - copy of input, but with signals merged 
 *
 * @par Corrections used: 
 *    - AliFMDCorrELossFit
 *
 * @par Histograms: 
 *    - For each ring (FMD1i, FMD2i, FMD2o, FMD3i, FMD3o) the distribution of 
 *      signals before and after the filter.  
 *    - For each ring (see above), an array of distributions of number of 
 *      hit strips for each vertex bin (if enabled - see Init method)
 * 
 *
 * @ingroup pwg2_forward_algo 
 */
class AliFMDSharingFilter : public TNamed
{
public: 
  /** 
   * Destructor
   */
  virtual ~AliFMDSharingFilter();
  /** 
   * Default Constructor - do not use 
   */
  AliFMDSharingFilter();
  /** 
   * Constructor 
   * 
   * @param title Title of object  - not significant 
   */
  AliFMDSharingFilter(const char* title);
  /** 
   * Copy constructor 
   * 
   * @param o Object to copy from 
   */
  AliFMDSharingFilter(const AliFMDSharingFilter& o);
  /** 
   * Assignment operator 
   * 
   * @param o Object to assign from 
   * 
   * @return Reference to this 
   */
  AliFMDSharingFilter& operator=(const AliFMDSharingFilter& o);

  /** 
   * Set the low cut used for sharing 
   * 
   * @param lowCut Low cut
   */
  void SetLowCut(Double_t lowCut=0) { fLowCut = lowCut; }
  /** 
   * Reset the low cut for sharing to use the fit range lower cut 
   * 
   */
  void UnsetLowCut() { fLowCut = 0; }
  /** 
   * Set the debug level.  The higher the value the more output 
   * 
   * @param dbg Debug level 
   */
  void SetDebug(Int_t dbg=1) { fDebug = dbg; }

  /** 
   * Enable use of angle corrected signals in the algorithm 
   * 
   * @param use If true, use angle corrected signals, 
   * otherwise use de-corrected signals.  In the final output, the 
   * signals are always angle corrected. 
   */
  void UseAngleCorrectedSignals(Bool_t use) { fCorrectAngles = use; }
  /** 
   * Set the number of landau width to subtract from the most probably
   * value to get the high cut for the merging algorithm.
   * 
   * @param n Number of @f$ \xi@f$ 
   */
  void SetNXi(Short_t n) { fNXi = n; }
  /** 
   * Filter the input AliESDFMD object
   * 
   * @param input     Input 
   * @param lowFlux   If this is a low-flux event 
   * @param output    Output AliESDFMD object 
   * 
   * @return True on success, false otherwise 
   */
  Bool_t Filter(const AliESDFMD& input, 
		Bool_t           lowFlux, 
		AliESDFMD&       output);
  /** 
   * Scale the histograms to the total number of events 
   * 
   * @param dir     Where the output is 
   * @param nEvents Number of events 
   */
  virtual void ScaleHistograms(TList* dir, Int_t nEvents);
  
  /** 
   * Define the output histograms.  These are put in a sub list of the
   * passed list.   The histograms are merged before the parent task calls 
   * AliAnalysisTaskSE::Terminate 
   * 
   * @param dir Directory to add to 
   */
  virtual void DefineOutput(TList* dir);
  /** 
   * Print information
   * 
   * @param option Not used 
   */
  virtual void Print(Option_t* option="") const;
protected:
  /** 
   * Internal data structure to keep track of the histograms
   */
  struct RingHistos : public AliForwardUtil::RingHistos
  { 
    /** 
     * Default CTOR
     */
    RingHistos();
    /** 
     * Constructor
     * 
     * @param d detector
     * @param r ring 
     */
    RingHistos(UShort_t d, Char_t r);
    /** 
     * Copy constructor 
     * 
     * @param o Object to copy from 
     */
    RingHistos(const RingHistos& o);
    /** 
     * Assignment operator 
     * 
     * @param o Object to assign from 
     * 
     * @return Reference to this 
     */
    RingHistos& operator=(const RingHistos& o);
    /** 
     * Destructor 
     */
    ~RingHistos();
    /** 
     * Clear this object
     */
    void Clear(const Option_t* ="") { fNHits = 0; } 
    /** 
     * Increase number of hits 
     * 
     */
    void Incr() { fNHits++; } 
    /** 
     * Finish off 
     * 
     */
    void Finish(); 
    /** 
     * Make output 
     * 
     * @param dir where to store 
     */
    void Output(TList* dir);
    /** 
     * Scale the histograms to the total number of events 
     * 
     * @param nEvents Number of events 
     * @param dir     Where the output is 
     */
    void ScaleHistograms(TList* dir, Int_t nEvents);
    TH1D*     fBefore;       // Distribution of signals before filter
    TH1D*     fAfter;        // Distribution of signals after filter
    TH1D*     fHits;         // Distribution of hit strips. 
    Int_t     fNHits;        // Number of hit strips per event
    ClassDef(RingHistos,1);
  };
  /** 
   * Get the ring histogram container 
   * 
   * @param d Detector
   * @param r Ring 
   * 
   * @return Ring histogram container 
   */
  RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
  /** 
   * Get the signal in a strip 
   * 
   * @param fmd   ESD object
   * @param d     Detector
   * @param r     Ring 
   * @param s     Sector 
   * @param t     Strip
   * 
   * @return The energy signal 
   */
  Double_t SignalInStrip(const AliESDFMD& fmd, 
			 UShort_t d,
			 Char_t   r,
			 UShort_t s,
			 UShort_t t) const;
  /** 
   * The actual algorithm 
   * 
   * @param mult      The unfiltered signal in the strip
   * @param eta       Psuedo rapidity 
   * @param prevE     Previous strip signal (or 0)
   * @param nextE     Next strip signal (or 0) 
   * @param lowFlux   Whether this is a low flux event 
   * @param d         Detector
   * @param r         Ring 
   * @param s         Sector 
   * @param t         Strip
   * @param usedPrev  Whether the previous strip was used in sharing or not
   * @param usedThis  Wether this strip was used in sharing or not. 
   * 
   * @return The filtered signal in the strip
   */
  Double_t MultiplicityOfStrip(Double_t mult,
			       Double_t eta,
			       Double_t prevE,
			       Double_t nextE,
			       Bool_t   lowFlux,
			       UShort_t d,
			       Char_t   r,
			       UShort_t s,
			       UShort_t t,
			       Bool_t&  usedPrev, 
			       Bool_t&  usedThis);
  /** 
   * Angle correct the signal 
   * 
   * @param mult Angle Un-corrected Signal 
   * @param eta  Pseudo-rapidity 
   * 
   * @return Angle corrected signal 
   */
  Double_t AngleCorrect(Double_t mult, Double_t eta) const;
  /** 
   * Angle de-correct the signal 
   * 
   * @param mult Angle corrected Signal 
   * @param eta  Pseudo-rapidity 
   * 
   * @return Angle un-corrected signal 
   */
  Double_t DeAngleCorrect(Double_t mult, Double_t eta) const;
  /**
   * Get the high cut.  The high cut is defined as the 
   * most-probably-value peak found from the energy distributions, minus 
   * 2 times the width of the corresponding Landau.
   */
  virtual Double_t GetHighCut(UShort_t d, Char_t r, Double_t eta) const;
  /**
   * Get the low cut.  Normally, the low cut is taken to be the lower
   * value of the fit range used when generating the energy loss fits.
   * However, if fLowCut is set (using SetLowCit) to a value greater
   * than 0, then that value is used.
   */
  virtual Double_t GetLowCut() const;

  TList    fRingHistos;    // List of histogram containers
  Double_t fLowCut;        // Low cut on sharing
  Bool_t   fCorrectAngles; // Whether to work on angle corrected signals
  Short_t  fNXi;           // Number of xi's from Delta to stop merging
  Int_t    fDebug;         // Debug level 

  ClassDef(AliFMDSharingFilter,1); //
};

#endif
// Local Variables:
//  mode: C++ 
// End:
Commit	Line	Data
7e4038b5	1	#ifndef ALIROOT_PWG2_FORWARD_ALIFMDSHARINGFILTER_H
	2	#define ALIROOT_PWG2_FORWARD_ALIFMDSHARINGFILTER_H
	3	#include <TNamed.h>
	4	#include <TH2.h>
	5	#include <TList.h>
9d99b0dd	6	#include "AliForwardUtil.h"
7e4038b5	7	class AliESDFMD;
	8	class TAxis;
	9	class TList;
	10	class TH2;
	11
	12	/**
	13	* Class to do the sharing correction. That is, a filter that merges
	14	* adjacent strip signals presumably originating from a single particle
	15	* that impinges on the detector in such a way that it deposite energy
	16	* into two or more strips.
	17	*
	18	* @par Input:
	19	* - AliESDFMD object - from reconstruction
	20	*
	21	* @par Output:
	22	* - AliESDFMD object - copy of input, but with signals merged
	23	*
	24	* @par Corrections used:
e8bf1690	25	* - AliFMDCorrELossFit
7e4038b5	26	*
	27	* @par Histograms:
	28	* - For each ring (FMD1i, FMD2i, FMD2o, FMD3i, FMD3o) the distribution of
	29	* signals before and after the filter.
	30	* - For each ring (see above), an array of distributions of number of
	31	* hit strips for each vertex bin (if enabled - see Init method)
	32	*
	33	*
e8bf1690	34	* @ingroup pwg2_forward_algo
7e4038b5	35	*/
	36	class AliFMDSharingFilter : public TNamed
	37	{
	38	public:
	39	/**
	40	* Destructor
	41	*/
	42	virtual ~AliFMDSharingFilter();
	43	/**
	44	* Default Constructor - do not use
	45	*/
	46	AliFMDSharingFilter();
	47	/**
	48	* Constructor
	49	*
	50	* @param title Title of object - not significant
	51	*/
	52	AliFMDSharingFilter(const char* title);
	53	/**
	54	* Copy constructor
	55	*
	56	* @param o Object to copy from
	57	*/
	58	AliFMDSharingFilter(const AliFMDSharingFilter& o);
	59	/**
	60	* Assignment operator
	61	*
	62	* @param o Object to assign from
	63	*
	64	* @return Reference to this
	65	*/
	66	AliFMDSharingFilter& operator=(const AliFMDSharingFilter& o);
	67
7e4038b5	68	/**
	69	* Set the low cut used for sharing
	70	*
	71	* @param lowCut Low cut
	72	*/
0bd4b00f	73	void SetLowCut(Double_t lowCut=0) { fLowCut = lowCut; }
	74	/**
	75	* Reset the low cut for sharing to use the fit range lower cut
	76	*
	77	*/
	78	void UnsetLowCut() { fLowCut = 0; }
ea3e5d95	79	/**
	80	* Set the debug level. The higher the value the more output
	81	*
	82	* @param dbg Debug level
	83	*/
	84	void SetDebug(Int_t dbg=1) { fDebug = dbg; }
7e4038b5	85
	86	/**
	87	* Enable use of angle corrected signals in the algorithm
	88	*
	89	* @param use If true, use angle corrected signals,
	90	* otherwise use de-corrected signals. In the final output, the
	91	* signals are always angle corrected.
	92	*/
	93	void UseAngleCorrectedSignals(Bool_t use) { fCorrectAngles = use; }
0bd4b00f	94	/**
	95	* Set the number of landau width to subtract from the most probably
	96	* value to get the high cut for the merging algorithm.
	97	*
	98	* @param n Number of @f$ \xi@f$
	99	*/
	100	void SetNXi(Short_t n) { fNXi = n; }
7e4038b5	101	/**
	102	* Filter the input AliESDFMD object
	103	*
	104	* @param input Input
	105	* @param lowFlux If this is a low-flux event
	106	* @param output Output AliESDFMD object
7e4038b5	107	*
	108	* @return True on success, false otherwise
	109	*/
	110	Bool_t Filter(const AliESDFMD& input,
	111	Bool_t lowFlux,
ea3e5d95	112	AliESDFMD& output);
7e4038b5	113	/**
	114	* Scale the histograms to the total number of events
	115	*
c389303e	116	* @param dir Where the output is
7e4038b5	117	* @param nEvents Number of events
7e4038b5	118	*/
e8bf1690	119	virtual void ScaleHistograms(TList* dir, Int_t nEvents);
7e4038b5	120
9d99b0dd	121	/**
	122	* Define the output histograms. These are put in a sub list of the
	123	* passed list. The histograms are merged before the parent task calls
	124	* AliAnalysisTaskSE::Terminate
	125	*
	126	* @param dir Directory to add to
	127	*/
e8bf1690	128	virtual void DefineOutput(TList* dir);
0bd4b00f	129	/**
	130	* Print information
	131	*
	132	* @param option Not used
	133	*/
e8bf1690	134	virtual void Print(Option_t* option="") const;
7e4038b5	135	protected:
	136	/**
	137	* Internal data structure to keep track of the histograms
	138	*/
9d99b0dd	139	struct RingHistos : public AliForwardUtil::RingHistos
7e4038b5	140	{
	141	/**
	142	* Default CTOR
	143	*/
	144	RingHistos();
	145	/**
	146	* Constructor
	147	*
	148	* @param d detector
	149	* @param r ring
	150	*/
	151	RingHistos(UShort_t d, Char_t r);
	152	/**
	153	* Copy constructor
	154	*
	155	* @param o Object to copy from
	156	*/
	157	RingHistos(const RingHistos& o);
	158	/**
	159	* Assignment operator
	160	*
	161	* @param o Object to assign from
	162	*
	163	* @return Reference to this
	164	*/
	165	RingHistos& operator=(const RingHistos& o);
	166	/**
	167	* Destructor
	168	*/
	169	~RingHistos();
	170	/**
c389303e	171	* Clear this object
7e4038b5	172	*/
7e4038b5	173	void Clear(const Option_t* ="") { fNHits = 0; }
c389303e	174	/**
	175	* Increase number of hits
	176	*
	177	*/
7e4038b5	178	void Incr() { fNHits++; }
c389303e	179	/**
	180	* Finish off
	181	*
	182	*/
7e4038b5	183	void Finish();
c389303e	184	/**
	185	* Make output
	186	*
	187	* @param dir where to store
	188	*/
7e4038b5	189	void Output(TList* dir);
9d99b0dd	190	/**
	191	* Scale the histograms to the total number of events
	192	*
	193	* @param nEvents Number of events
c389303e	194	* @param dir Where the output is
9d99b0dd	195	*/
9d99b0dd	196	void ScaleHistograms(TList* dir, Int_t nEvents);
7e4038b5	197	TH1D* fBefore; // Distribution of signals before filter
	198	TH1D* fAfter; // Distribution of signals after filter
	199	TH1D* fHits; // Distribution of hit strips.
	200	Int_t fNHits; // Number of hit strips per event
9d99b0dd	201	ClassDef(RingHistos,1);
7e4038b5	202	};
	203	/**
	204	* Get the ring histogram container
	205	*
	206	* @param d Detector
	207	* @param r Ring
	208	*
	209	* @return Ring histogram container
	210	*/
	211	RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
	212	/**
	213	* Get the signal in a strip
	214	*
	215	* @param fmd ESD object
	216	* @param d Detector
	217	* @param r Ring
	218	* @param s Sector
	219	* @param t Strip
	220	*
	221	* @return The energy signal
	222	*/
	223	Double_t SignalInStrip(const AliESDFMD& fmd,
	224	UShort_t d,
	225	Char_t r,
	226	UShort_t s,
	227	UShort_t t) const;
	228	/**
	229	* The actual algorithm
	230	*
	231	* @param mult The unfiltered signal in the strip
	232	* @param eta Psuedo rapidity
	233	* @param prevE Previous strip signal (or 0)
	234	* @param nextE Next strip signal (or 0)
	235	* @param lowFlux Whether this is a low flux event
	236	* @param d Detector
	237	* @param r Ring
	238	* @param s Sector
	239	* @param t Strip
	240	* @param usedPrev Whether the previous strip was used in sharing or not
	241	* @param usedThis Wether this strip was used in sharing or not.
	242	*
	243	* @return The filtered signal in the strip
	244	*/
	245	Double_t MultiplicityOfStrip(Double_t mult,
	246	Double_t eta,
	247	Double_t prevE,
	248	Double_t nextE,
	249	Bool_t lowFlux,
	250	UShort_t d,
	251	Char_t r,
	252	UShort_t s,
	253	UShort_t t,
	254	Bool_t& usedPrev,
	255	Bool_t& usedThis);
	256	/**
	257	* Angle correct the signal
	258	*
	259	* @param mult Angle Un-corrected Signal
	260	* @param eta Pseudo-rapidity
	261	*
	262	* @return Angle corrected signal
	263	*/
	264	Double_t AngleCorrect(Double_t mult, Double_t eta) const;
	265	/**
266	* Angle de-correct the signal
267	*
268	* @param mult Angle corrected Signal
269	* @param eta Pseudo-rapidity
270	*
271	* @return Angle un-corrected signal
272	*/
273	Double_t DeAngleCorrect(Double_t mult, Double_t eta) const;
274	/**
275	* Get the high cut. The high cut is defined as the
276	* most-probably-value peak found from the energy distributions, minus
277	* 2 times the width of the corresponding Landau.
278	*/
279	virtual Double_t GetHighCut(UShort_t d, Char_t r, Double_t eta) const;
0bd4b00f	280	/**
	281	* Get the low cut. Normally, the low cut is taken to be the lower
	282	* value of the fit range used when generating the energy loss fits.
	283	* However, if fLowCut is set (using SetLowCit) to a value greater
	284	* than 0, then that value is used.
	285	*/
	286	virtual Double_t GetLowCut() const;
7e4038b5	287
	288	TList fRingHistos; // List of histogram containers
	289	Double_t fLowCut; // Low cut on sharing
	290	Bool_t fCorrectAngles; // Whether to work on angle corrected signals
0bd4b00f	291	Short_t fNXi; // Number of xi's from Delta to stop merging
ea3e5d95	292	Int_t fDebug; // Debug level
7e4038b5	293
	294	ClassDef(AliFMDSharingFilter,1); //
	295	};
	296
	297	#endif
	298	// Local Variables:
	299	// mode: C++
	300	// End: