[u/mrichter/AliRoot.git] / ANALYSIS / TenderSupplies / AliEMCALTenderSupply.h

#ifndef ALIEMCALTENDERSUPPLY_H
#define ALIEMCALTENDERSUPPLY_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

////////////////////////////////////////////////////////////////////////
//                                                                    //
//  EMCAL tender, apply corrections to EMCAl clusters                 //
//  and do track matching.                                            //
//  Author: Deepa Thomas (Utrecht University)                         //
//  Later mods/rewrite: Jiri Kral (University of Jyvaskyla)           //
//  S. Aiola, C. Loizides : Make it work for AODs                     //
//                                                                    //
////////////////////////////////////////////////////////////////////////

#include "AliTenderSupply.h"

class TTree;
class TClonesArray;

class AliVCluster;
class AliEMCALRecoUtils;
class AliEMCALGeometry;
class TGeoHMatrix;
class TTree;
class TFile;
class TString;
class AliEMCALClusterizer;
class AliEMCALAfterBurnerUF;
class AliEMCALRecParam;
class AliAnalysisTaskSE;
class AliVEvent;

class AliEMCALTenderSupply: public AliTenderSupply {
  
public:
  AliEMCALTenderSupply();
  AliEMCALTenderSupply(const char *name, const AliTender *tender=NULL);
  AliEMCALTenderSupply(const char *name, AliAnalysisTaskSE *task);
  virtual ~AliEMCALTenderSupply();

  enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4,kBeamTestCorrected=5};
  enum MisalignSettings{kdefault=0,kSurveybyS=1,kSurveybyM=2};

  virtual void Init();
  virtual void ProcessEvent();

  void     SetTask(AliAnalysisTaskSE *task)               { fTask = task                     ;}
  void     SetDefaults();

  void     SetEMCALGeometryName(const char *name)         { fEMCALGeoName = name             ;}
  TString  EMCALGeometryName()                      const { return fEMCALGeoName             ;}

  void     SetDebugLevel(Int_t level)                     { fDebugLevel=level                ;}

  void     SetBasePath(const Char_t *basePath)            { fBasePath = basePath             ;}
 
  void     SetConfigFileName(const char *name)            { fConfigName = name               ;}

  void     SetNonLinearityFunction(Int_t fun)             { fNonLinearFunc = fun             ;}
  Int_t    GetNonLinearityFunction() const                { return fNonLinearFunc            ;}
  
  void     SetNonLinearityThreshold(Int_t threshold)      { fNonLinearThreshold = threshold  ;} //only for Alexei's non linearity correction
  Int_t    GetNonLinearityThreshold()               const { return fNonLinearThreshold       ;}

  void     SwitchOnNonLinearityCorrection()               { fDoNonLinearity = kTRUE          ;}
  void     SwitchOffNonLinearityCorrection()              { fDoNonLinearity = kFALSE         ;}

  void     SwitchOnReCalibrateCluster()                   { fReCalibCluster = kTRUE          ;}
  void     SwitchOffReCalibrateCluster()                  { fReCalibCluster = kFALSE         ;}

  void     SwitchOnRecalculateClusPos()                   { fRecalClusPos = kTRUE            ;}
  void     SwitchOffRecalculateClusPos()                  { fRecalClusPos = kFALSE           ;}

  void     SetMisalignmentMatrixSurvey(Int_t misalignSurvey) { fMisalignSurvey = misalignSurvey ;}
  Int_t    GetMisalignmentMatrixSurvey() const               { return fMisalignSurvey           ;}    

  void     SwitchOnCellFiducialRegion()                   { fFiducial = kTRUE                ;}
  void     SwitchOffCellFiducialRegion()                  { fFiducial = kFALSE               ;}

  void     SetNumberOfCellsFromEMCALBorder(Int_t n)       { fNCellsFromEMCALBorder = n       ;}
  Int_t    GetNumberOfCellsFromEMCALBorder()        const { return fNCellsFromEMCALBorder    ;}

  void     SwitchOnRecalDistBadChannel()                  { fRecalDistToBadChannels = kTRUE  ;}
  void     SwitchOffRecalDistBadChannel()                 { fRecalDistToBadChannels = kFALSE ;}

  void     SwitchOnRecalShowerShape()                     { fRecalShowerShape = kTRUE        ;}
  void     SwitchOffRecalShowerShape()                    { fRecalShowerShape = kFALSE       ;}

  Float_t  GetRCut()                                const { return fRcut                     ;}
  void     SetRCut(Float_t rcut)                          { fRcut = rcut                     ;}

  Double_t GetMass()                                const { return fMass                     ;}
  void     SetMass(Double_t mass)                         { fMass = mass                     ;}

  Double_t GetStep()                                const { return fStep                     ;}
  void     SetStep(Double_t step)                         { fStep = step                     ;}

  Double_t GetEtaCut()                              const { return fEtacut                   ;}
  void     SetEtaCut(Double_t eta)                        { fEtacut = eta                    ;}

  Double_t GetPhiCut()                              const { return fPhicut                   ;}
  void     SetPhiCut(Double_t phi)                        { fPhicut = phi                    ;}

  Float_t  GetExoticCellFraction()                  const { return fExoticCellFraction       ;}
  void     SetExoticCellFraction(Float_t f)               { fExoticCellFraction = f          ;}

  Float_t  GetExoticCellDiffTime()                  const { return fExoticCellDiffTime       ;}
  void     SetExoticCellDiffTime(Float_t f)               { fExoticCellDiffTime = f          ;}

  Float_t  GetExoticCellMinAmplitude()              const { return fExoticCellMinAmplitude   ;}
  void     SetExoticCellMinAmplitude(Float_t f)           { fExoticCellMinAmplitude = f      ;}

  void     SwitchOnReclustering()                         { fReClusterize = kTRUE            ;}
  void     SwitchOffReclustering()                        { fReClusterize = kFALSE           ;}

  void     SwitchOnCutEtaPhiSum()                         { fCutEtaPhiSum=kTRUE;      fCutEtaPhiSeparate=kFALSE ;}
  void     SwitchOnCutEtaPhiSeparate()                    { fCutEtaPhiSeparate=kTRUE; fCutEtaPhiSum=kFALSE      ;}
  
  void     SwitchOnLoadOwnGeometryMatrices()              { fLoadGeomMatrices = kTRUE        ;}
  void     SwitchOffLoadOwnGeometryMatrices()             { fLoadGeomMatrices = kFALSE       ;}
  void     SetGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i]    = m           ;}
  
  AliEMCALRecParam   *GetRecParam() const                 { return fRecParam                 ;} 
  void                SetRecParam(AliEMCALRecParam *p)    { fRecParam = p                    ;}
 
  AliEMCALRecoUtils  *GetRecoUtils() const                { return fEMCALRecoUtils           ;}
  void                SetRecoUtils(AliEMCALRecoUtils *r)  { fEMCALRecoUtils = r              ;}
  
  void     SwitchOnUpdateCell()                           { fUpdateCell = kTRUE              ;} 
  void     SwitchOffUpdateCell()                          { fUpdateCell = kFALSE             ;}  

  void     SwitchOnBadCellRemove()                        { fBadCellRemove = kTRUE           ;} 
  void     SwitchOffBadCellRemove()                       { fBadCellRemove = kFALSE          ;}  

  void     SwitchOnClusterBadChannelCheck()               { fClusterBadChannelCheck = kTRUE  ;} 
  void     SwitchOffClusterBadChannelCheck()              { fClusterBadChannelCheck = kFALSE ;}  

  void     SwitchOnExoticCellRemove()                     { fRejectExoticCells = kTRUE       ;} 
  void     SwitchOffExoticCellRemove()                    { fRejectExoticCells = kFALSE      ;}  

  void     SwitchOnClusterExoticChannelCheck()            { fRejectExoticClusters = kTRUE    ;} 
  void     SwitchOffClusterExoticChannelCheck()           { fRejectExoticClusters = kFALSE   ;}  

  void     SwitchOnCalibrateEnergy()                      { fCalibrateEnergy = kTRUE         ;} 
  void     SwitchOffCalibrateEnergy()                     { fCalibrateEnergy = kFALSE        ;}  

  void     SwitchOnCalibrateTime()                        { fCalibrateTime = kTRUE           ;} 
  void     SwitchOffCalibrateTime()                       { fCalibrateTime = kFALSE          ;}  

  void     SwitchOnUpdateCellOnly()                       { fDoUpdateOnly = kTRUE            ;} 
  void     SwitchOffUpdateCellOnly()                      { fDoUpdateOnly = kFALSE           ;}  
 
  void     SwitchOnTrackMatch()                           { fDoTrackMatch = kTRUE            ;}
  void     SwitchOffTrackMatch()                          { fDoTrackMatch = kFALSE           ;}

  void     SetPass(const char* p)                         { fFilepass = p; fGetPassFromFileName = kFALSE; }
  void     UnsetPass()                                    { fFilepass = ""; fGetPassFromFileName = kTRUE; }
  
  //MC label methods
  
  void     RemapMCLabelForAODs(Int_t &label);
  void     SwitchOnRemapMCLabelForAODs()                  { fRemapMCLabelForAODs  = kTRUE   ; }
  void     SwitchOffRemapMCLabelForAODs()                 { fRemapMCLabelForAODs  = kFALSE  ; }
  
  void     SetClustersMCLabelFromOriginalClusters() ;  
  void     SwitchOnUseClusterMCLabelForCell(Int_t opt = 2) { fSetCellMCLabelFromCluster = opt ; }
  void     SwitchOffUseClusterMCLabelForCell()             { fSetCellMCLabelFromCluster = 0   ; }

  
private:

  AliVEvent* GetEvent();
  TString    GetBeamType();
  Bool_t     RunChanged() const;
  Int_t      InitBadChannels();
  Bool_t     InitClusterization();
  Int_t      InitRecParam();
  Bool_t     InitMisalignMatrix();
  Int_t      InitRecalib();
  Int_t      InitRunDepRecalib();
  Int_t      InitTimeCalibration();
  void       Clusterize();
  void       FillDigitsArray();
  void       GetPass();
  void       RecPoints2Clusters(TClonesArray *clus);
  void       RecalibrateCells();
  void       UpdateCells();
  void       UpdateClusters();

  AliAnalysisTaskSE     *fTask;                   // analysis task
  Int_t                  fRun;                    // current run number
  AliEMCALGeometry      *fEMCALGeo;               // EMCAL geometry
  TString                fEMCALGeoName;           // name of geometry to use.
  AliEMCALRecoUtils     *fEMCALRecoUtils;         // pointer to EMCAL utilities for clusterization
  TString                fConfigName;             // name of analysis configuration file
  Int_t                  fDebugLevel;             // debug level
  Int_t                  fNonLinearFunc;          // non linearity function 
  Int_t                  fNonLinearThreshold;     // non linearity threshold value for kBeamTesh non linearity function   
  Bool_t                 fReCalibCluster;         // switch for Recalibrate clusters
  Bool_t                 fUpdateCell;             // flag cell update
  Bool_t                 fCalibrateEnergy;        // flag cell energy calibration
  Bool_t                 fCalibrateTime;          // flag cell time calibration
  Bool_t                 fCalibrateTimeParamAvailable; // Check if time calib param are available to set properly time cuts
  Bool_t                 fDoNonLinearity;         // nNon linearity correction flag
  Bool_t                 fBadCellRemove;          // zero bad cells
  Bool_t                 fRejectExoticCells;      // reject exotic cells
  Bool_t                 fRejectExoticClusters;   // recect clusters with exotic cells
  Bool_t                 fClusterBadChannelCheck; // check clusters for bad channels
  TGeoHMatrix           *fEMCALMatrix[12];        // geometry matrices with misalignments
  Bool_t                 fRecalClusPos;           // switch for applying missalignment
  Bool_t                 fFiducial;               // switch for checking cells in the fiducial region
  Int_t                  fNCellsFromEMCALBorder;  // number os cells from EMCAL border  
  Bool_t                 fRecalDistToBadChannels; // switch for recalculation cluster position from bad channel    
  Bool_t                 fRecalShowerShape;       // switch for recalculation of the shower shape
  TTree                 *fInputTree;              //!input data tree
  TFile                 *fInputFile;              //!input data file 
  Bool_t                 fGetPassFromFileName;    // get fFilepass from file name
  TString                fFilepass;               // input data pass number
  Double_t               fMass;                   // mass for track matching
  Double_t               fStep;                   // step size during track matching
  Bool_t                 fCutEtaPhiSum;           // swicth to apply residual cut together
  Bool_t                 fCutEtaPhiSeparate;      // swicth to apply residual cut separately
  Float_t                fRcut;                   // residual cut for track matching  
  Float_t                fEtacut;                 // eta cut for track matching  
  Float_t                fPhicut;                 // phi cut for track matching  
  TString                fBasePath;               // base folder path to get root files 
  Bool_t                 fReClusterize;           // switch for reclustering
  AliEMCALClusterizer   *fClusterizer;            //!clusterizer 
  Bool_t                 fGeomMatrixSet;          // set geometry matrices only once, for the first event.         
  Bool_t                 fLoadGeomMatrices;       // matrices set from configuration, not get from geometry.root or from ESDs/AODs
  AliEMCALRecParam      *fRecParam;               // reconstruction parameters container
  Bool_t                 fDoTrackMatch;           // do track matching
  Bool_t                 fDoUpdateOnly;           // do only update of cells
  AliEMCALAfterBurnerUF *fUnfolder;               //!unfolding procedure
  TClonesArray          *fDigitsArr;              //!digits array
  TObjArray             *fClusterArr;             //!recpoints array
  Int_t                  fMisalignSurvey;         // misalignment matrix survey  
  Float_t                fExoticCellFraction;     // good cell if fraction < 1-ecross/ecell
  Float_t                fExoticCellDiffTime;     // if time of candidate to exotic and close cell is too different (in ns), it must be noisy, set amp to 0
  Float_t                fExoticCellMinAmplitude; // check for exotic only if amplitud is larger than this value

  // MC labels
  Int_t                  fOrgClusterCellId[12672]; // Array ID of cluster to wich the cell belongs in unmodified clusters
 
  Int_t                  fSetCellMCLabelFromCluster; // Use cluster MC label as cell label:
                                                     // 0 - get the MC label stored in cells
                                                     // 1 - assign to the cell the MC lable of the cluster
                                                     // 2 - get the original clusters id, add all the MC labels
  TClonesArray *         fTempClusterArr      ;      //! Temporal clusters array to recover the MC of original cluster if fSetCellMCLabelFromCluster=2
  Bool_t                 fRemapMCLabelForAODs ;      // Remap AOD cells MC label
  
  AliEMCALTenderSupply(            const AliEMCALTenderSupply&c);
  AliEMCALTenderSupply& operator= (const AliEMCALTenderSupply&c);
  
  ClassDef(AliEMCALTenderSupply, 16); // EMCAL tender task
};
#endif
Commit	Line	Data
6d67b5a7	1	#ifndef ALIEMCALTENDERSUPPLY_H
	2	#define ALIEMCALTENDERSUPPLY_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	////////////////////////////////////////////////////////////////////////
	8	// //
	9	// EMCAL tender, apply corrections to EMCAl clusters //
766cc9de	10	// and do track matching. //
766cc9de	11	// Author: Deepa Thomas (Utrecht University) //
c05ffa77	12	// Later mods/rewrite: Jiri Kral (University of Jyvaskyla) //
dd8e12d1	13	// S. Aiola, C. Loizides : Make it work for AODs //
6d67b5a7	14	// //
	15	////////////////////////////////////////////////////////////////////////
	16
766cc9de	17	#include "AliTenderSupply.h"
6d67b5a7	18
b20bc239	19	class TTree;
	20	class TClonesArray;
	21
6d67b5a7	22	class AliVCluster;
	23	class AliEMCALRecoUtils;
	24	class AliEMCALGeometry;
	25	class TGeoHMatrix;
	26	class TTree;
	27	class TFile;
	28	class TString;
b20bc239	29	class AliEMCALClusterizer;
b20bc239	30	class AliEMCALAfterBurnerUF;
4d3c549c	31	class AliEMCALRecParam;
dd8e12d1	32	class AliAnalysisTaskSE;
dd8e12d1	33	class AliVEvent;
acf53135	34
6d67b5a7	35	class AliEMCALTenderSupply: public AliTenderSupply {
	36
	37	public:
	38	AliEMCALTenderSupply();
	39	AliEMCALTenderSupply(const char name, const AliTender tender=NULL);
dd8e12d1	40	AliEMCALTenderSupply(const char name, AliAnalysisTaskSE task);
6d67b5a7	41	virtual ~AliEMCALTenderSupply();
6d67b5a7	42
ef51b5f7	43	enum NonlinearityFunctions{kPi0MC=0,kPi0GammaGamma=1,kPi0GammaConversion=2,kNoCorrection=3,kBeamTest=4,kBeamTestCorrected=5};
a0beb012	44	enum MisalignSettings{kdefault=0,kSurveybyS=1,kSurveybyM=2};
ef51b5f7	45
766cc9de	46	virtual void Init();
766cc9de	47	virtual void ProcessEvent();
dd8e12d1	48
dd8e12d1	49	void SetTask(AliAnalysisTaskSE *task) { fTask = task ;}
98e8eede	50	void SetDefaults();
dd8e12d1	51
e768f43c	52	void SetEMCALGeometryName(const char *name) { fEMCALGeoName = name ;}
766cc9de	53	TString EMCALGeometryName() const { return fEMCALGeoName ;}
6d67b5a7	54
766cc9de	55	void SetDebugLevel(Int_t level) { fDebugLevel=level ;}
6d67b5a7	56
766cc9de	57	void SetBasePath(const Char_t *basePath) { fBasePath = basePath ;}
b20bc239	58
e768f43c	59	void SetConfigFileName(const char *name) { fConfigName = name ;}
413a7463	60
766cc9de	61	void SetNonLinearityFunction(Int_t fun) { fNonLinearFunc = fun ;}
766cc9de	62	Int_t GetNonLinearityFunction() const { return fNonLinearFunc ;}
6d67b5a7	63
766cc9de	64	void SetNonLinearityThreshold(Int_t threshold) { fNonLinearThreshold = threshold ;} //only for Alexei's non linearity correction
766cc9de	65	Int_t GetNonLinearityThreshold() const { return fNonLinearThreshold ;}
6d67b5a7	66
50b7a951	67	void SwitchOnNonLinearityCorrection() { fDoNonLinearity = kTRUE ;}
	68	void SwitchOffNonLinearityCorrection() { fDoNonLinearity = kFALSE ;}
	69
766cc9de	70	void SwitchOnReCalibrateCluster() { fReCalibCluster = kTRUE ;}
766cc9de	71	void SwitchOffReCalibrateCluster() { fReCalibCluster = kFALSE ;}
c958a2f7	72
766cc9de	73	void SwitchOnRecalculateClusPos() { fRecalClusPos = kTRUE ;}
766cc9de	74	void SwitchOffRecalculateClusPos() { fRecalClusPos = kFALSE ;}
6d67b5a7	75
dd8e12d1	76	void SetMisalignmentMatrixSurvey(Int_t misalignSurvey) { fMisalignSurvey = misalignSurvey ;}
dd8e12d1	77	Int_t GetMisalignmentMatrixSurvey() const { return fMisalignSurvey ;}
acf53135	78
766cc9de	79	void SwitchOnCellFiducialRegion() { fFiducial = kTRUE ;}
766cc9de	80	void SwitchOffCellFiducialRegion() { fFiducial = kFALSE ;}
6d67b5a7	81
50b7a951	82	void SetNumberOfCellsFromEMCALBorder(Int_t n) { fNCellsFromEMCALBorder = n ;}
50b7a951	83	Int_t GetNumberOfCellsFromEMCALBorder() const { return fNCellsFromEMCALBorder ;}
6d67b5a7	84
766cc9de	85	void SwitchOnRecalDistBadChannel() { fRecalDistToBadChannels = kTRUE ;}
766cc9de	86	void SwitchOffRecalDistBadChannel() { fRecalDistToBadChannels = kFALSE ;}
6d67b5a7	87
50b7a951	88	void SwitchOnRecalShowerShape() { fRecalShowerShape = kTRUE ;}
	89	void SwitchOffRecalShowerShape() { fRecalShowerShape = kFALSE ;}
	90
766cc9de	91	Float_t GetRCut() const { return fRcut ;}
766cc9de	92	void SetRCut(Float_t rcut) { fRcut = rcut ;}
6d67b5a7	93
766cc9de	94	Double_t GetMass() const { return fMass ;}
766cc9de	95	void SetMass(Double_t mass) { fMass = mass ;}
6d67b5a7	96
766cc9de	97	Double_t GetStep() const { return fStep ;}
766cc9de	98	void SetStep(Double_t step) { fStep = step ;}
6d67b5a7	99
6b7df55d	100	Double_t GetEtaCut() const { return fEtacut ;}
50b7a951	101	void SetEtaCut(Double_t eta) { fEtacut = eta ;}
	102
	103	Double_t GetPhiCut() const { return fPhicut ;}
	104	void SetPhiCut(Double_t phi) { fPhicut = phi ;}
	105
	106	Float_t GetExoticCellFraction() const { return fExoticCellFraction ;}
	107	void SetExoticCellFraction(Float_t f) { fExoticCellFraction = f ;}
428f69ce	108
50b7a951	109	Float_t GetExoticCellDiffTime() const { return fExoticCellDiffTime ;}
	110	void SetExoticCellDiffTime(Float_t f) { fExoticCellDiffTime = f ;}
	111
	112	Float_t GetExoticCellMinAmplitude() const { return fExoticCellMinAmplitude ;}
	113	void SetExoticCellMinAmplitude(Float_t f) { fExoticCellMinAmplitude = f ;}
428f69ce	114
6b7df55d	115	void SwitchOnReclustering() { fReClusterize = kTRUE ;}
6b7df55d	116	void SwitchOffReclustering() { fReClusterize = kFALSE ;}
428f69ce	117
766cc9de	118	void SwitchOnCutEtaPhiSum() { fCutEtaPhiSum=kTRUE; fCutEtaPhiSeparate=kFALSE ;}
766cc9de	119	void SwitchOnCutEtaPhiSeparate() { fCutEtaPhiSeparate=kTRUE; fCutEtaPhiSum=kFALSE ;}
b20bc239	120
766cc9de	121	void SwitchOnLoadOwnGeometryMatrices() { fLoadGeomMatrices = kTRUE ;}
	122	void SwitchOffLoadOwnGeometryMatrices() { fLoadGeomMatrices = kFALSE ;}
	123	void SetGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i] = m ;}
3b233502	124
8b775c10	125	AliEMCALRecParam *GetRecParam() const { return fRecParam ;}
a0beb012	126	void SetRecParam(AliEMCALRecParam *p) { fRecParam = p ;}
8b775c10	127
acf53135	128	AliEMCALRecoUtils *GetRecoUtils() const { return fEMCALRecoUtils ;}
5b6de4be	129	void SetRecoUtils(AliEMCALRecoUtils *r) { fEMCALRecoUtils = r ;}
5b6de4be	130
8b775c10	131	void SwitchOnUpdateCell() { fUpdateCell = kTRUE ;}
50b7a951	132	void SwitchOffUpdateCell() { fUpdateCell = kFALSE ;}
	133
	134	void SwitchOnBadCellRemove() { fBadCellRemove = kTRUE ;}
	135	void SwitchOffBadCellRemove() { fBadCellRemove = kFALSE ;}
	136
	137	void SwitchOnClusterBadChannelCheck() { fClusterBadChannelCheck = kTRUE ;}
	138	void SwitchOffClusterBadChannelCheck() { fClusterBadChannelCheck = kFALSE ;}
	139
	140	void SwitchOnExoticCellRemove() { fRejectExoticCells = kTRUE ;}
	141	void SwitchOffExoticCellRemove() { fRejectExoticCells = kFALSE ;}
	142
	143	void SwitchOnClusterExoticChannelCheck() { fRejectExoticClusters = kTRUE ;}
	144	void SwitchOffClusterExoticChannelCheck() { fRejectExoticClusters = kFALSE ;}
	145
	146	void SwitchOnCalibrateEnergy() { fCalibrateEnergy = kTRUE ;}
	147	void SwitchOffCalibrateEnergy() { fCalibrateEnergy = kFALSE ;}
	148
	149	void SwitchOnCalibrateTime() { fCalibrateTime = kTRUE ;}
	150	void SwitchOffCalibrateTime() { fCalibrateTime = kFALSE ;}
a0beb012	151
a0beb012	152	void SwitchOnUpdateCellOnly() { fDoUpdateOnly = kTRUE ;}
50b7a951	153	void SwitchOffUpdateCellOnly() { fDoUpdateOnly = kFALSE ;}
6d67b5a7	154
6e6de0c3	155	void SwitchOnTrackMatch() { fDoTrackMatch = kTRUE ;}
	156	void SwitchOffTrackMatch() { fDoTrackMatch = kFALSE ;}
	157
2b0653b9	158	void SetPass(const char* p) { fFilepass = p; fGetPassFromFileName = kFALSE; }
2b0653b9	159	void UnsetPass() { fFilepass = ""; fGetPassFromFileName = kTRUE; }
d2744cb4	160
	161	//MC label methods
	162
	163	void RemapMCLabelForAODs(Int_t &label);
	164	void SwitchOnRemapMCLabelForAODs() { fRemapMCLabelForAODs = kTRUE ; }
	165	void SwitchOffRemapMCLabelForAODs() { fRemapMCLabelForAODs = kFALSE ; }
	166
	167	void SetClustersMCLabelFromOriginalClusters() ;
	168	void SwitchOnUseClusterMCLabelForCell(Int_t opt = 2) { fSetCellMCLabelFromCluster = opt ; }
	169	void SwitchOffUseClusterMCLabelForCell() { fSetCellMCLabelFromCluster = 0 ; }
	170
	171
6d67b5a7	172	private:
6d67b5a7	173
dd8e12d1	174	AliVEvent* GetEvent();
dd8e12d1	175	TString GetBeamType();
dd8e12d1	176	Bool_t RunChanged() const;
dd8e12d1	177	Int_t InitBadChannels();
dd8e12d1	178	Bool_t InitClusterization();
dd8e12d1	179	Int_t InitRecParam();
dd8e12d1	180	Bool_t InitMisalignMatrix();
dd8e12d1	181	Int_t InitRecalib();
7bf608c9	182	Int_t InitRunDepRecalib();
dd8e12d1	183	Int_t InitTimeCalibration();
dd8e12d1	184	void Clusterize();
dd8e12d1	185	void FillDigitsArray();
dd8e12d1	186	void GetPass();
dd8e12d1	187	void RecPoints2Clusters(TClonesArray *clus);
dd8e12d1	188	void RecalibrateCells();
dd8e12d1	189	void UpdateCells();
dd8e12d1	190	void UpdateClusters();
766cc9de	191
98e8eede	192	AliAnalysisTaskSE *fTask; // analysis task
98e8eede	193	Int_t fRun; // current run number
6931af96	194	AliEMCALGeometry *fEMCALGeo; // EMCAL geometry
98e8eede	195	TString fEMCALGeoName; // name of geometry to use.
	196	AliEMCALRecoUtils *fEMCALRecoUtils; // pointer to EMCAL utilities for clusterization
	197	TString fConfigName; // name of analysis configuration file
	198	Int_t fDebugLevel; // debug level
	199	Int_t fNonLinearFunc; // non linearity function
	200	Int_t fNonLinearThreshold; // non linearity threshold value for kBeamTesh non linearity function
	201	Bool_t fReCalibCluster; // switch for Recalibrate clusters
	202	Bool_t fUpdateCell; // flag cell update
6a764914	203	Bool_t fCalibrateEnergy; // flag cell energy calibration
	204	Bool_t fCalibrateTime; // flag cell time calibration
	205	Bool_t fCalibrateTimeParamAvailable; // Check if time calib param are available to set properly time cuts
98e8eede	206	Bool_t fDoNonLinearity; // nNon linearity correction flag
98e8eede	207	Bool_t fBadCellRemove; // zero bad cells
50b7a951	208	Bool_t fRejectExoticCells; // reject exotic cells
50b7a951	209	Bool_t fRejectExoticClusters; // recect clusters with exotic cells
98e8eede	210	Bool_t fClusterBadChannelCheck; // check clusters for bad channels
	211	TGeoHMatrix *fEMCALMatrix[12]; // geometry matrices with misalignments
	212	Bool_t fRecalClusPos; // switch for applying missalignment
	213	Bool_t fFiducial; // switch for checking cells in the fiducial region
	214	Int_t fNCellsFromEMCALBorder; // number os cells from EMCAL border
	215	Bool_t fRecalDistToBadChannels; // switch for recalculation cluster position from bad channel
	216	Bool_t fRecalShowerShape; // switch for recalculation of the shower shape
	217	TTree *fInputTree; //!input data tree
	218	TFile *fInputFile; //!input data file
2b0653b9	219	Bool_t fGetPassFromFileName; // get fFilepass from file name
2b0653b9	220	TString fFilepass; // input data pass number
98e8eede	221	Double_t fMass; // mass for track matching
	222	Double_t fStep; // step size during track matching
	223	Bool_t fCutEtaPhiSum; // swicth to apply residual cut together
	224	Bool_t fCutEtaPhiSeparate; // swicth to apply residual cut separately
	225	Float_t fRcut; // residual cut for track matching
	226	Float_t fEtacut; // eta cut for track matching
	227	Float_t fPhicut; // phi cut for track matching
	228	TString fBasePath; // base folder path to get root files
	229	Bool_t fReClusterize; // switch for reclustering
	230	AliEMCALClusterizer *fClusterizer; //!clusterizer
	231	Bool_t fGeomMatrixSet; // set geometry matrices only once, for the first event.
	232	Bool_t fLoadGeomMatrices; // matrices set from configuration, not get from geometry.root or from ESDs/AODs
	233	AliEMCALRecParam *fRecParam; // reconstruction parameters container
	234	Bool_t fDoTrackMatch; // do track matching
	235	Bool_t fDoUpdateOnly; // do only update of cells
	236	AliEMCALAfterBurnerUF *fUnfolder; //!unfolding procedure
	237	TClonesArray *fDigitsArr; //!digits array
	238	TObjArray *fClusterArr; //!recpoints array
6931af96	239	Int_t fMisalignSurvey; // misalignment matrix survey
98e8eede	240	Float_t fExoticCellFraction; // good cell if fraction < 1-ecross/ecell
	241	Float_t fExoticCellDiffTime; // if time of candidate to exotic and close cell is too different (in ns), it must be noisy, set amp to 0
	242	Float_t fExoticCellMinAmplitude; // check for exotic only if amplitud is larger than this value
8b775c10	243
d2744cb4	244	// MC labels
	245	Int_t fOrgClusterCellId[12672]; // Array ID of cluster to wich the cell belongs in unmodified clusters
	246
	247	Int_t fSetCellMCLabelFromCluster; // Use cluster MC label as cell label:
	248	// 0 - get the MC label stored in cells
	249	// 1 - assign to the cell the MC lable of the cluster
	250	// 2 - get the original clusters id, add all the MC labels
	251	TClonesArray * fTempClusterArr ; //! Temporal clusters array to recover the MC of original cluster if fSetCellMCLabelFromCluster=2
	252	Bool_t fRemapMCLabelForAODs ; // Remap AOD cells MC label
6e6de0c3	253
d2744cb4	254	AliEMCALTenderSupply( const AliEMCALTenderSupply&c);
6d67b5a7	255	AliEMCALTenderSupply& operator= (const AliEMCALTenderSupply&c);
6d67b5a7	256
6a764914	257	ClassDef(AliEMCALTenderSupply, 16); // EMCAL tender task
6d67b5a7	258	};
6d67b5a7	259	#endif