[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliDielectronCF.h

#ifndef ALIDIELECTRONCF_H
#define ALIDIELECTRONCF_H
/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//#############################################################
//#                                                           #
//#             Class AliDielectronCF                         #
//#       Dielectron Correction Framework Manager             #
//#                                                           #
//#  Authors:                                                 #
//#   Anton     Andronic, GSI / A.Andronic@gsi.de             #
//#   Ionut C.  Arsene,   GSI / I.C.Arsene@gsi.de             #
//#   Julian    Book,     Uni Ffm / Julian.Book@cern.ch       #
//#   Frederick Kramer,   Uni Ffm, / Frederick.Kramer@cern.ch #
//#   Magnus    Mager,    CERN / Magnus.Mager@cern.ch         #
//#   WooJin J. Park,     GSI / W.J.Park@gsi.de               #
//#   Jens      Wiechula, Uni HD / Jens.Wiechula@cern.ch      #
//#                                                           #
//#############################################################


#include <TNamed.h>
#include <TVectorDfwd.h>
#include <TBits.h>
#include "AliDielectronVarManager.h"

class AliAnalysisCuts;
class AliAnalysisFilter;
class AliCFContainer;
class AliDielectronPair;
class TObjArray;

class AliDielectronCF : public TNamed {
public:
  enum {kNmaxAddSteps=50};
  
  AliDielectronCF();
  AliDielectronCF(const char* name, const char* title);
  virtual ~AliDielectronCF();

  void SetStepForMCtruth(Bool_t steps=kTRUE)           { fStepForMCtruth=steps;           }
  Bool_t GetStepForMCtruth() const                     { return fStepForMCtruth;          }
  void SetStepForNoCutsMCmotherPid(Bool_t steps=kTRUE) { fStepForNoCutsMCmotherPid=steps; }
  void SetStepForAfterAllCuts(Bool_t steps=kTRUE)      { fStepForAfterAllCuts=steps;      }
  void SetStepForPreFilter(Bool_t steps=kTRUE)         { fStepForPreFilter=steps;         }
  void SetStepsForEachCut(Bool_t steps=kTRUE)          { fStepsForEachCut=steps;          }
  void SetStepsForCutsIncreasing(Bool_t steps=kTRUE)   { fStepsForCutsIncreasing=steps;   }
  void SetStepsForSignal(Bool_t steps=kTRUE)           { fStepsForSignal=steps;           }
  void SetStepsForBackground(Bool_t steps=kTRUE)       { fStepsForBackground=steps;       }
  void SetStepsForMCtruthOnly(Bool_t steps=kTRUE)      { fStepsForMCtruthOnly=steps;       }
  
  void SetPdgMother(Int_t pdg) { fPdgMother=pdg; }
  void SetSignalsMC(TObjArray* array)    {fSignalsMC = array;}
  
  void AddStepMask(UInt_t mask)                  { fStepMasks[fNStepMasks++]=mask; }
  
  void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins,
                   Double_t min, Double_t max, Bool_t leg=kFALSE, Bool_t log=kFALSE);
  void AddVariable(AliDielectronVarManager::ValueTypes type, const char* binLimitStr, Bool_t leg=kFALSE);
  void AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD *binLimits, Bool_t leg=kFALSE);
  
  void InitialiseContainer(const AliAnalysisFilter& filter);

  Int_t GetNvarsPair()     const {return fNVars;}
  Int_t GetNvarsLeg()      const {return fNVarsLeg;}

  UInt_t GetVariablePair(UInt_t var) const {return (var>=(UInt_t)AliDielectronVarManager::kNMaxValues)? (UInt_t)AliDielectronVarManager::kNMaxValues+1:fVariables[var];}
  UInt_t GetVariableLeg(UInt_t var) const {return (var>=(UInt_t)AliDielectronVarManager::kNMaxValues)? (UInt_t)AliDielectronVarManager::kNMaxValues+1:fVariablesLeg[var];}

//   void Fill(UInt_t mask, const TObject *particle);
  void Fill(UInt_t mask, const AliDielectronPair *particle);
  void FillMC(const TObject *particle);
  void FillMC(Int_t label1, Int_t label2, Int_t nSignal);

  AliCFContainer* GetContainer() const { return fCfContainer; }
  
private:
  TBits     *fUsedVars;             // list of used variables

  UInt_t          fVariables[AliDielectronVarManager::kNMaxValues]; //configured variables
  UInt_t          fVariablesLeg[AliDielectronVarManager::kNMaxValues]; //configured variables for the legs
  
  Int_t           fNSteps;                     // number of selection steps
  
  Int_t           fNVars;                      // number of variables
  TObjArray      *fVarBinLimits;               // array of bin limits
  
  Int_t           fNVarsLeg;                   // number of variables for the legs
  TObjArray      *fVarBinLimitsLeg;            //  array of bin limits of the legs
  
  Int_t           fNCuts;                      // Number of cuts in the filter concerned

  Double_t        *fValues;                    //! Value array for filling the container
  Bool_t          *fIsMCTruth;                 //! Buffer array for MC truth information
  
  Bool_t fStepForMCtruth;               //create a step for the MC truth
  Bool_t fStepForNoCutsMCmotherPid;     //create a step for before cuts, but with MC truth of the mother
  Bool_t fStepForAfterAllCuts;          //create a step for before cuts, but with MC truth of the mother
  Bool_t fStepForPreFilter;             //create a step after PreFilter application
  Bool_t fStepsForEachCut;              //create steps for each cut?
  Bool_t fStepsForCutsIncreasing;       //create steps for increasing cut combinatons?
                                        //e.g. cut1&cut2, cut1&cut2&cut3 ...
  Bool_t fStepsForSignal;               //steps for pure signal
  Bool_t fStepsForBackground;           //steps for pure background
  Bool_t fStepsForMCtruthOnly;          //Switch off all pair steps, allow only MC truth Class
  
  UInt_t fStepMasks[kNmaxAddSteps];      //steps for additional cut combinatons
  UInt_t fNStepMasks;                    //number of configured step masks

  Int_t fPdgMother;                      //Pdg code of MCtruth validation
  TObjArray* fSignalsMC;                 //! array of MC signals to be studied
  AliCFContainer* fCfContainer;          //the CF container

  Bool_t fHasMC;                         //if MC info is available
  Int_t  fNAddSteps;                     //number of additional MC related steps per cut step

  TVectorD* MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const;
  TVectorD* MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const;
  
  AliDielectronCF(const AliDielectronCF &c);
  AliDielectronCF &operator=(const AliDielectronCF &c);
  
  ClassDef(AliDielectronCF,5)  //Dielectron Correction Framework handler
};

#endif
Commit	Line	Data
b2a297fa	1	#ifndef ALIDIELECTRONCF_H
	2	#define ALIDIELECTRONCF_H
	3	/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	//#############################################################
	7	//# #
	8	//# Class AliDielectronCF #
	9	//# Dielectron Correction Framework Manager #
	10	//# #
	11	//# Authors: #
	12	//# Anton Andronic, GSI / A.Andronic@gsi.de #
	13	//# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de #
	14	//# Julian Book, Uni Ffm / Julian.Book@cern.ch #
	15	//# Frederick Kramer, Uni Ffm, / Frederick.Kramer@cern.ch #
	16	//# Magnus Mager, CERN / Magnus.Mager@cern.ch #
	17	//# WooJin J. Park, GSI / W.J.Park@gsi.de #
	18	//# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
	19	//# #
	20	//#############################################################
	21
	22
	23
	24	#include <TNamed.h>
61d106d3	25	#include <TVectorDfwd.h>
a94c2e7e	26	#include <TBits.h>
b2a297fa	27	#include "AliDielectronVarManager.h"
	28
	29	class AliAnalysisCuts;
	30	class AliAnalysisFilter;
	31	class AliCFContainer;
6551594b	32	class AliDielectronPair;
61d106d3	33	class TObjArray;
b2a297fa	34
	35	class AliDielectronCF : public TNamed {
	36	public:
	37	enum {kNmaxAddSteps=50};
	38
	39	AliDielectronCF();
	40	AliDielectronCF(const char* name, const char* title);
	41	virtual ~AliDielectronCF();
	42
e123f993	43	void SetStepForMCtruth(Bool_t steps=kTRUE) { fStepForMCtruth=steps; }
ba15fdfb	44	Bool_t GetStepForMCtruth() const { return fStepForMCtruth; }
e123f993	45	void SetStepForNoCutsMCmotherPid(Bool_t steps=kTRUE) { fStepForNoCutsMCmotherPid=steps; }
e123f993	46	void SetStepForAfterAllCuts(Bool_t steps=kTRUE) { fStepForAfterAllCuts=steps; }
554e40f8	47	void SetStepForPreFilter(Bool_t steps=kTRUE) { fStepForPreFilter=steps; }
e123f993	48	void SetStepsForEachCut(Bool_t steps=kTRUE) { fStepsForEachCut=steps; }
e123f993	49	void SetStepsForCutsIncreasing(Bool_t steps=kTRUE) { fStepsForCutsIncreasing=steps; }
572b0139	50	void SetStepsForSignal(Bool_t steps=kTRUE) { fStepsForSignal=steps; }
572b0139	51	void SetStepsForBackground(Bool_t steps=kTRUE) { fStepsForBackground=steps; }
5720c765	52	void SetStepsForMCtruthOnly(Bool_t steps=kTRUE) { fStepsForMCtruthOnly=steps; }
b2a297fa	53
b2a297fa	54	void SetPdgMother(Int_t pdg) { fPdgMother=pdg; }
ba15fdfb	55	void SetSignalsMC(TObjArray* array) {fSignalsMC = array;}
b2a297fa	56
	57	void AddStepMask(UInt_t mask) { fStepMasks[fNStepMasks++]=mask; }
	58
3505bfad	59	void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins,
	60	Double_t min, Double_t max, Bool_t leg=kFALSE, Bool_t log=kFALSE);
	61	void AddVariable(AliDielectronVarManager::ValueTypes type, const char* binLimitStr, Bool_t leg=kFALSE);
	62	void AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD *binLimits, Bool_t leg=kFALSE);
61d106d3	63
b2a297fa	64	void InitialiseContainer(const AliAnalysisFilter& filter);
5720c765	65
	66	Int_t GetNvarsPair() const {return fNVars;}
	67	Int_t GetNvarsLeg() const {return fNVarsLeg;}
	68
ac390e40	69	UInt_t GetVariablePair(UInt_t var) const {return (var>=(UInt_t)AliDielectronVarManager::kNMaxValues)? (UInt_t)AliDielectronVarManager::kNMaxValues+1:fVariables[var];}
ac390e40	70	UInt_t GetVariableLeg(UInt_t var) const {return (var>=(UInt_t)AliDielectronVarManager::kNMaxValues)? (UInt_t)AliDielectronVarManager::kNMaxValues+1:fVariablesLeg[var];}
5720c765	71
6551594b	72	// void Fill(UInt_t mask, const TObject *particle);
6551594b	73	void Fill(UInt_t mask, const AliDielectronPair *particle);
b2a297fa	74	void FillMC(const TObject *particle);
ba15fdfb	75	void FillMC(Int_t label1, Int_t label2, Int_t nSignal);
ba15fdfb	76
b2a297fa	77	AliCFContainer* GetContainer() const { return fCfContainer; }
b2a297fa	78
6551594b	79	private:
a94c2e7e	80	TBits *fUsedVars; // list of used variables
a94c2e7e	81
b2a297fa	82	UInt_t fVariables[AliDielectronVarManager::kNMaxValues]; //configured variables
6551594b	83	UInt_t fVariablesLeg[AliDielectronVarManager::kNMaxValues]; //configured variables for the legs
b2a297fa	84
b2a297fa	85	Int_t fNSteps; // number of selection steps
6551594b	86
b2a297fa	87	Int_t fNVars; // number of variables
3505bfad	88	TObjArray *fVarBinLimits; // array of bin limits
	89
	90	Int_t fNVarsLeg; // number of variables for the legs
	91	TObjArray *fVarBinLimitsLeg; // array of bin limits of the legs
6551594b	92
ac390e40	93	Int_t fNCuts; // Number of cuts in the filter concerned
b2a297fa	94
ac390e40	95	Double_t *fValues; //! Value array for filling the container
ac390e40	96	Bool_t *fIsMCTruth; //! Buffer array for MC truth information
6551594b	97
e123f993	98	Bool_t fStepForMCtruth; //create a step for the MC truth
	99	Bool_t fStepForNoCutsMCmotherPid; //create a step for before cuts, but with MC truth of the mother
	100	Bool_t fStepForAfterAllCuts; //create a step for before cuts, but with MC truth of the mother
554e40f8	101	Bool_t fStepForPreFilter; //create a step after PreFilter application
e123f993	102	Bool_t fStepsForEachCut; //create steps for each cut?
	103	Bool_t fStepsForCutsIncreasing; //create steps for increasing cut combinatons?
	104	//e.g. cut1&cut2, cut1&cut2&cut3 ...
572b0139	105	Bool_t fStepsForSignal; //steps for pure signal
572b0139	106	Bool_t fStepsForBackground; //steps for pure background
5720c765	107	Bool_t fStepsForMCtruthOnly; //Switch off all pair steps, allow only MC truth Class
572b0139	108
b2a297fa	109	UInt_t fStepMasks[kNmaxAddSteps]; //steps for additional cut combinatons
	110	UInt_t fNStepMasks; //number of configured step masks
	111
	112	Int_t fPdgMother; //Pdg code of MCtruth validation
ba15fdfb	113	TObjArray* fSignalsMC; //! array of MC signals to be studied
b2a297fa	114	AliCFContainer* fCfContainer; //the CF container
572b0139	115
	116	Bool_t fHasMC; //if MC info is available
	117	Int_t fNAddSteps; //number of additional MC related steps per cut step
3505bfad	118
	119	TVectorD* MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const;
	120	TVectorD* MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const;
b2a297fa	121
	122	AliDielectronCF(const AliDielectronCF &c);
	123	AliDielectronCF &operator=(const AliDielectronCF &c);
	124
a94c2e7e	125	ClassDef(AliDielectronCF,5) //Dielectron Correction Framework handler
b2a297fa	126	};
	127
	128	#endif