[u/mrichter/AliRoot.git] / TRD / AliTRDPreprocessorOffline.h

#ifndef ALITRDPREPROCESSOROFFLINE_H
#define ALITRDPREPROCESSOROFFLINE_H

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

//
//
//    Class to create OCDB entries - processing the results of the OFFLINE calibration
//


#include "TNamed.h"
#include "AliTRDCalChamberStatus.h"
#include <THnSparse.h>
class TObjArray;
class AliTRDCalDet;
class TH2I;
class TProfile2D;
class AliTRDCalibraVdriftLinearFit;
class AliTRDCalibraExbAltFit;
class TH1I;
class TH2F;
class TString;


class AliTRDPreprocessorOffline:public TNamed { 
public:
  enum{ kGain = 0,
	kVdriftPHDet = 1,
	kVdriftPHPad = 2,
	kT0PHDet = 3,
	kT0PHPad = 4,
	kVdriftLinear = 5,
	kLorentzLinear = 6,
	kChamberStatus = 7,
	kPRF = 8,
	kExbAlt = 9,
	kNumCalibObjs = 10
  };
  enum { kGainNotEnoughStatsButFill = 2,
	 kVdriftNotEnoughStatsButFill = 4,
	 kGainNotEnoughStatsNotFill = 8,
	 kVdriftNotEnoughStatsNotFill = 16,
	 kTimeOffsetNotEnoughStatsNotFill = 32,
	 kExBErrorRange = 64};  
  enum { kGainErrorOld = 2,
	 kVdriftErrorOld = 4,
	 kExBErrorOld = 8,
	 kGainErrorRange = 16,
	 kVdriftErrorRange = 32,
	 kTimeOffsetErrorRange = 64,
	 kChamberStatusErrorRange = 128};  


  AliTRDPreprocessorOffline();
  virtual ~AliTRDPreprocessorOffline();

  Bool_t Init(const Char_t* fileName);
  void Process(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage);

  // settings
  void SetLinearFitForVdrift(Bool_t methodsecond) { fMethodSecond = methodsecond;};
  void SetNameList(TString nameList) { fNameList = nameList;};
  void     SetMinStatsVdriftT0PH(Int_t minStatsVdriftT0PH)           { fMinStatsVdriftT0PH = minStatsVdriftT0PH; }  
  void     SetMinStatsVdriftLinear(Int_t minStatsVdriftLinear)       { fMinStatsVdriftLinear = minStatsVdriftLinear; }  
  void     SetMinStatsGain(Int_t minStatsGain)                       { fMinStatsGain = minStatsGain; }  
  void     SetMinStatsPRF(Int_t minStatsPRF)                         { fMinStatsPRF = minStatsPRF; }  
  void     SetMinStatsChamberStatus(Int_t minStatsChamberStatus)     { fMinStatsChamberStatus = minStatsChamberStatus; }
	void     SetSingleMinStatsChamberStatus(Int_t minSingleStatsChamberStatus) { fMinSingleStatsChamberStatus = minSingleStatsChamberStatus; }
  void     SetLimitValidateNoData(Int_t nodatavalidate)              { fNoDataValidate = nodatavalidate; };
  void     SetLimitValidateBadCalib(Int_t badcalibvalidate)          { fBadCalibValidate = badcalibvalidate; };
  void     SetBackCorrectGain(Bool_t backCorrectGain)                { fBackCorrectGain = backCorrectGain; }
  void     SetBackCorrectVdrift(Bool_t backCorrectVdrift)            { fBackCorrectVdrift = backCorrectVdrift; }
  void     SetNoExBUsedInReco(Bool_t noExBUsedInReco)                { fNoExBUsedInReco    = noExBUsedInReco;   };
  void     SetSwitchOnValidation(Bool_t switchOnValidation)          { fSwitchOnValidation = switchOnValidation;};
  void     SetRMSBadCalibratedGain(Double_t rms)                     { fRMSBadCalibratedGain = rms;};
  void     SetRMSBadCalibratedVdrift(Double_t rms)                   { fRMSBadCalibratedVdrift = rms;};
  void     SetRMSBadCalibratedExB(Double_t rms)                      { fRMSBadCalibratedExB = rms;};
  void     SetRobustFitDriftVelocity(Bool_t robustFitDriftVelocity)  { fRobustFitDriftVelocity = robustFitDriftVelocity;};
  void     SetRobustFitExbAlt(Bool_t robustFitExbAlt)                { fRobustFitExbAlt = robustFitExbAlt;};
  void     SetAlternativeDriftVelocityFit(Bool_t alt)                { fAlternativeVdrfitFit = alt;};
  void     SetAlternativeExbAltFit(Bool_t alt)                       { fAlternativeExbAltFit = alt;};


  Bool_t GetLinearFitForVdrift() const { return fMethodSecond;};
  TString GetNameList() const { return fNameList;}; 

  // status
  Bool_t      CheckStatus(Int_t status, Int_t bitMask) const;
  void PrintStatus() const;

  Bool_t      IsGainNotEnoughStatsButFill() const 
    { return CheckStatus(fStatusNeg, kGainNotEnoughStatsButFill);  };
  Bool_t      IsGainNotEnoughStatsNotFill() const 
    { return CheckStatus(fStatusNeg, kGainNotEnoughStatsNotFill);  };
  Bool_t      IsVdriftNotEnoughStatsButFill() const 
    { return CheckStatus(fStatusNeg, kVdriftNotEnoughStatsButFill);  };
  Bool_t      IsVdriftNotEnoughStatsNotFill() const 
    { return CheckStatus(fStatusNeg, kVdriftNotEnoughStatsNotFill);  };
  Bool_t      IsTimeOffsetNotEnoughStatsNotFill() const 
    { return CheckStatus(fStatusNeg, kTimeOffsetNotEnoughStatsNotFill);  };
  Bool_t      IsExBErrorRange() const 
    { return CheckStatus(fStatusNeg, kExBErrorRange);  };
  
  Bool_t      IsGainErrorOld() const 
    { return CheckStatus(fStatusPos, kGainErrorOld);  };
  Bool_t      IsVdriftErrorOld() const 
    { return CheckStatus(fStatusPos, kVdriftErrorOld);  };
  Bool_t      IsExBErrorOld() const 
    { return CheckStatus(fStatusPos, kExBErrorOld);  };
  Bool_t      IsGainErrorRange() const 
    { return CheckStatus(fStatusPos, kGainErrorRange);  };
  Bool_t      IsVdriftErrorRange() const 
    { return CheckStatus(fStatusPos, kVdriftErrorRange);  };
  Bool_t      IsTimeOffsetErrorRange() const 
    { return CheckStatus(fStatusPos, kTimeOffsetErrorRange);  };
  Bool_t      IsChamberStatusErrorRange() const 
    { return CheckStatus(fStatusPos, kChamberStatusErrorRange);  };
  

  // Back corrections
  void SetCalDetGain(AliTRDCalDet *calDetGainUsed) {fCalDetGainUsed = calDetGainUsed;};
  void SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed);
  void SetCalDetVdriftExB(AliTRDCalDet *calDetVdriftUsed,AliTRDCalDet *calDetExBUsed) {fCalDetVdriftUsed = calDetVdriftUsed; fCalDetExBUsed = calDetExBUsed;};
  Bool_t SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion);
  Bool_t SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb);
  
  AliTRDCalDet *GetCalDetGain() const { return fCalDetGainUsed;};
  AliTRDCalDet *GetCalDetVdrift() const { return fCalDetVdriftUsed;};
  Int_t    GetFirstRunGainUsed() const                               { return fFirstRunGainUsed;       }
  Int_t    GetVersionGainUsed() const                                { return fVersionGainUsed;        }
  Int_t    GetSubVersionGainUsed() const                             { return fSubVersionGainUsed;     }
  Int_t    GetFirstRunVdriftUsed() const                             { return fFirstRunVdriftUsed;     }
  Int_t    GetVersionVdriftUsed() const                              { return fVersionVdriftUsed;      }
  Int_t    GetSubVersionVdriftUsed() const                           { return fSubVersionVdriftUsed;   }
  Int_t    GetFirstRunExBUsed() const                                { return fFirstRunExBUsed;        }
  Int_t    GetVersionExBUsed() const                                 { return fVersionExBUsed;         }
  Int_t    GetSubVersionExBUsed() const                              { return fSubVersionExBUsed;      }


  // Internal functions

  void CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
  void CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
  void CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber,  TString  ocdbStorage="");
  void CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber,  TString  ocdbStorage="");
  void CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");

  Bool_t ReadStatusGlobal(const Char_t* fileName="CalibObjects.root");
  Bool_t ReadGainGlobal(const Char_t* fileName="CalibObjects.root");
  Bool_t ReadVdriftT0Global(const Char_t* fileName="CalibObjects.root");
  Bool_t ReadVdriftLinearFitGlobal(const Char_t* fileName="CalibObjects.root");
  Bool_t ReadExbAltFitGlobal(const Char_t* fileName="CalibObjects.root");
  Bool_t ReadPRFGlobal(const Char_t* fileName="CalibObjects.root");

  Bool_t AnalyzeGain(); 
  Bool_t AnalyzeVdriftT0(); 
  Bool_t AnalyzeVdriftLinearFit(); 
  Bool_t AnalyzeExbAltFit();
  Bool_t AnalyzePRF();
  Bool_t AnalyzeChamberStatus(); 
  
  void CorrectFromDetGainUsed();
  void CorrectFromDetVdriftUsed();
  
  void UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
  void UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
  void UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
  void UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
  void UpdateOCDBGain(Int_t  startRunNumber, Int_t endRunNumber, const char* storagePath);
  void UpdateOCDBPRF(Int_t  startRunNumber, Int_t endRunNumber, const char* storagePath);
  void UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);

  Bool_t ValidateGain();
  Bool_t ValidateVdrift();
  Bool_t ValidateExB();
  Bool_t ValidateT0();
  Bool_t ValidatePRF() const;
  Bool_t ValidateChamberStatus();

  Int_t    GetStatus() const;
  Int_t    GetStatusPos() const                                      { return fStatusPos;              }
  Int_t    GetStatusNeg() const                                      { return fStatusNeg;              }
 

 private:
  Bool_t fMethodSecond;                      // Second Method for drift velocity   
  TString fNameList;                         // Name of the list
  AliTRDCalDet *fCalDetGainUsed;             // CalDet used and to be corrected for
  AliTRDCalDet *fCalDetVdriftUsed;           // CalDet used and to be corrected for
  AliTRDCalDet *fCalDetExBUsed;              // CalDet used and to be corrected for
  TH2I *fCH2d;                               // Gain
  TProfile2D *fPH2d;                         // Drift velocity first method
  TProfile2D *fPRF2d;                        // PRF
  THnSparseI *fSparse;                       // chamberstatus
  AliTRDCalibraVdriftLinearFit *fAliTRDCalibraVdriftLinearFit; // Drift velocity second method
  AliTRDCalibraExbAltFit* fAliTRDCalibraExbAltFit; //ExB alternative method
  TH1I *fNEvents;                         // Number of events 
  TH2F *fAbsoluteGain;                    // Absolute Gain calibration
  TObjArray * fPlots;                     // array with some plots to check
  TObjArray * fCalibObjects;              // array with calibration objects 
  Int_t    fFirstRunGainUsed;             // first run gain used 
  Int_t    fVersionGainUsed;              // VersionGainUsed 
  Int_t    fSubVersionGainUsed;           // SubVersionGainUsed
  Int_t    fFirstRunVdriftUsed;           // FirstRunVdrift 
  Int_t    fVersionVdriftUsed;            // VersionVdriftUsed 
  Int_t    fSubVersionVdriftUsed;         // SubVersionVdriftUsed
  Int_t    fFirstRunExBUsed;              // FirstRunExB 
  Int_t    fVersionExBUsed;               // VersionExBUsed 
  Int_t    fSubVersionExBUsed;            // SubVersionExBUsed
  Bool_t   fNoExBUsedInReco;              // ExB not used yet in the reco
  Bool_t   fSwitchOnValidation;           // Validation
  Bool_t   fVdriftValidated;              // Vdrift validation
  Bool_t   fExBValidated;                 // ExB validation
  Bool_t   fT0Validated;                  // T0 validation
  Int_t    fMinStatsVdriftT0PH;           // MinStats VdriftT0
  Int_t    fMinStatsVdriftLinear;         // MinStats Vdrift Linear
  Int_t    fMinStatsGain;                 // MinStats Gain
  Int_t    fMinStatsPRF;                  // MinStats PRF
  Int_t    fMinStatsChamberStatus;        // MinStats ChamberStatus
	Double_t fMinSingleStatsChamberStatus;  // MinStats per chamber in % of mean (ChamberStatus)
  Bool_t   fBackCorrectGain;              // Back correction afterwards gain  
  Bool_t   fBackCorrectVdrift;            // Back correction afterwards vdrift
  Bool_t   fNotEnoughStatisticsForTheGain;// Take the chamber per chamber distribution from the default distribution
  Bool_t   fNotEnoughStatisticsForTheVdriftLinear;// Take the chamber per chamber distribution from the default distribution
  Int_t    fStatusNeg;                    // Info but ok
  Int_t    fStatusPos;                    // Problems
  Int_t    fBadCalib[18];                 // number of bad calibrated chambers per sm
  Int_t    fNoData[18];                   // number of  chambers w/o data per sm
  Int_t    fBadCalibValidate;             // validation limit for bad calibrated chambers
  Int_t    fNoDataValidate;               // validation limit for chamber w/o data (sm w/o data excluded)
  Double_t fRMSBadCalibratedGain;         // value to decide when it is bad calibrated 
  Double_t fRMSBadCalibratedVdrift;       // value to decide when it is bad calibrated 
  Double_t fRMSBadCalibratedExB;          // value to decide when it is bad calibrated 
  Bool_t   fRobustFitDriftVelocity;       // Robust fit for the drift velocity
  Bool_t   fRobustFitExbAlt;              // Robust fit for the exb alt 
  Bool_t   fAlternativeVdrfitFit;         // Alternative fitting method for vdrift calibration
  Bool_t   fAlternativeExbAltFit;         // Alternative fitting method for the alternative exb calibarion method

  Int_t GetSubVersion(TString name) const;
  Int_t GetVersion(TString name) const;
  Int_t GetFirstRun(TString name) const;

  
private:
  AliTRDPreprocessorOffline& operator=(const AliTRDPreprocessorOffline&); // not implemented
  AliTRDPreprocessorOffline(const AliTRDPreprocessorOffline&); // not implemented
  ClassDef(AliTRDPreprocessorOffline,3)
};

#endif
Commit	Line	Data
b3fcfd96	1	#ifndef ALITRDPREPROCESSOROFFLINE_H
	2	#define ALITRDPREPROCESSOROFFLINE_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	// Class to create OCDB entries - processing the results of the OFFLINE calibration
	10	//
	11
	12
	13	#include "TNamed.h"
81a5aeca	14	#include "AliTRDCalChamberStatus.h"
83d0cc79	15	#include <THnSparse.h>
b3fcfd96	16	class TObjArray;
01239968	17	class AliTRDCalDet;
b3fcfd96	18	class TH2I;
	19	class TProfile2D;
	20	class AliTRDCalibraVdriftLinearFit;
a0bb5615	21	class AliTRDCalibraExbAltFit;
b3fcfd96	22	class TH1I;
b3fcfd96	23	class TH2F;
01239968	24	class TString;
b3fcfd96	25
	26
	27	class AliTRDPreprocessorOffline:public TNamed {
	28	public:
a0bb5615	29	enum{ kGain = 0,
	30	kVdriftPHDet = 1,
	31	kVdriftPHPad = 2,
	32	kT0PHDet = 3,
	33	kT0PHPad = 4,
	34	kVdriftLinear = 5,
	35	kLorentzLinear = 6,
	36	kChamberStatus = 7,
	37	kPRF = 8,
	38	kExbAlt = 9,
	39	kNumCalibObjs = 10
	40	};
840ec79d	41	enum { kGainNotEnoughStatsButFill = 2,
	42	kVdriftNotEnoughStatsButFill = 4,
	43	kGainNotEnoughStatsNotFill = 8,
	44	kVdriftNotEnoughStatsNotFill = 16,
	45	kTimeOffsetNotEnoughStatsNotFill = 32,
	46	kExBErrorRange = 64};
	47	enum { kGainErrorOld = 2,
	48	kVdriftErrorOld = 4,
	49	kExBErrorOld = 8,
	50	kGainErrorRange = 16,
	51	kVdriftErrorRange = 32,
	52	kTimeOffsetErrorRange = 64,
	53	kChamberStatusErrorRange = 128};
82b413fd	54
82b413fd	55
b3fcfd96	56	AliTRDPreprocessorOffline();
	57	virtual ~AliTRDPreprocessorOffline();
	58
83d0cc79	59	Bool_t Init(const Char_t* fileName);
	60	void Process(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage);
	61
	62	// settings
	63	void SetLinearFitForVdrift(Bool_t methodsecond) { fMethodSecond = methodsecond;};
	64	void SetNameList(TString nameList) { fNameList = nameList;};
	65	void SetMinStatsVdriftT0PH(Int_t minStatsVdriftT0PH) { fMinStatsVdriftT0PH = minStatsVdriftT0PH; }
	66	void SetMinStatsVdriftLinear(Int_t minStatsVdriftLinear) { fMinStatsVdriftLinear = minStatsVdriftLinear; }
	67	void SetMinStatsGain(Int_t minStatsGain) { fMinStatsGain = minStatsGain; }
	68	void SetMinStatsPRF(Int_t minStatsPRF) { fMinStatsPRF = minStatsPRF; }
	69	void SetMinStatsChamberStatus(Int_t minStatsChamberStatus) { fMinStatsChamberStatus = minStatsChamberStatus; }
17aa2935	70	void SetSingleMinStatsChamberStatus(Int_t minSingleStatsChamberStatus) { fMinSingleStatsChamberStatus = minSingleStatsChamberStatus; }
83d0cc79	71	void SetLimitValidateNoData(Int_t nodatavalidate) { fNoDataValidate = nodatavalidate; };
	72	void SetLimitValidateBadCalib(Int_t badcalibvalidate) { fBadCalibValidate = badcalibvalidate; };
	73	void SetBackCorrectGain(Bool_t backCorrectGain) { fBackCorrectGain = backCorrectGain; }
	74	void SetBackCorrectVdrift(Bool_t backCorrectVdrift) { fBackCorrectVdrift = backCorrectVdrift; }
	75	void SetNoExBUsedInReco(Bool_t noExBUsedInReco) { fNoExBUsedInReco = noExBUsedInReco; };
	76	void SetSwitchOnValidation(Bool_t switchOnValidation) { fSwitchOnValidation = switchOnValidation;};
	77	void SetRMSBadCalibratedGain(Double_t rms) { fRMSBadCalibratedGain = rms;};
	78	void SetRMSBadCalibratedVdrift(Double_t rms) { fRMSBadCalibratedVdrift = rms;};
	79	void SetRMSBadCalibratedExB(Double_t rms) { fRMSBadCalibratedExB = rms;};
2a1a7b36	80	void SetRobustFitDriftVelocity(Bool_t robustFitDriftVelocity) { fRobustFitDriftVelocity = robustFitDriftVelocity;};
2a1a7b36	81	void SetRobustFitExbAlt(Bool_t robustFitExbAlt) { fRobustFitExbAlt = robustFitExbAlt;};
661c7be6	82	void SetAlternativeDriftVelocityFit(Bool_t alt) { fAlternativeVdrfitFit = alt;};
661c7be6	83	void SetAlternativeExbAltFit(Bool_t alt) { fAlternativeExbAltFit = alt;};
2a1a7b36	84
83d0cc79	85
	86	Bool_t GetLinearFitForVdrift() const { return fMethodSecond;};
	87	TString GetNameList() const { return fNameList;};
	88
	89	// status
	90	Bool_t CheckStatus(Int_t status, Int_t bitMask) const;
	91	void PrintStatus() const;
	92
82b413fd	93	Bool_t IsGainNotEnoughStatsButFill() const
	94	{ return CheckStatus(fStatusNeg, kGainNotEnoughStatsButFill); };
	95	Bool_t IsGainNotEnoughStatsNotFill() const
	96	{ return CheckStatus(fStatusNeg, kGainNotEnoughStatsNotFill); };
	97	Bool_t IsVdriftNotEnoughStatsButFill() const
	98	{ return CheckStatus(fStatusNeg, kVdriftNotEnoughStatsButFill); };
	99	Bool_t IsVdriftNotEnoughStatsNotFill() const
	100	{ return CheckStatus(fStatusNeg, kVdriftNotEnoughStatsNotFill); };
	101	Bool_t IsTimeOffsetNotEnoughStatsNotFill() const
840ec79d	102	{ return CheckStatus(fStatusNeg, kTimeOffsetNotEnoughStatsNotFill); };
	103	Bool_t IsExBErrorRange() const
	104	{ return CheckStatus(fStatusNeg, kExBErrorRange); };
82b413fd	105
	106	Bool_t IsGainErrorOld() const
	107	{ return CheckStatus(fStatusPos, kGainErrorOld); };
	108	Bool_t IsVdriftErrorOld() const
	109	{ return CheckStatus(fStatusPos, kVdriftErrorOld); };
840ec79d	110	Bool_t IsExBErrorOld() const
840ec79d	111	{ return CheckStatus(fStatusPos, kExBErrorOld); };
82b413fd	112	Bool_t IsGainErrorRange() const
	113	{ return CheckStatus(fStatusPos, kGainErrorRange); };
	114	Bool_t IsVdriftErrorRange() const
	115	{ return CheckStatus(fStatusPos, kVdriftErrorRange); };
	116	Bool_t IsTimeOffsetErrorRange() const
	117	{ return CheckStatus(fStatusPos, kTimeOffsetErrorRange); };
	118	Bool_t IsChamberStatusErrorRange() const
	119	{ return CheckStatus(fStatusPos, kChamberStatusErrorRange); };
	120
82b413fd	121
83d0cc79	122	// Back corrections
01239968	123	void SetCalDetGain(AliTRDCalDet *calDetGainUsed) {fCalDetGainUsed = calDetGainUsed;};
840ec79d	124	void SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed);
840ec79d	125	void SetCalDetVdriftExB(AliTRDCalDet calDetVdriftUsed,AliTRDCalDet calDetExBUsed) {fCalDetVdriftUsed = calDetVdriftUsed; fCalDetExBUsed = calDetExBUsed;};
83d0cc79	126	Bool_t SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion);
	127	Bool_t SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb);
	128
01239968	129	AliTRDCalDet *GetCalDetGain() const { return fCalDetGainUsed;};
4c865c34	130	AliTRDCalDet *GetCalDetVdrift() const { return fCalDetVdriftUsed;};
83d0cc79	131	Int_t GetFirstRunGainUsed() const { return fFirstRunGainUsed; }
	132	Int_t GetVersionGainUsed() const { return fVersionGainUsed; }
	133	Int_t GetSubVersionGainUsed() const { return fSubVersionGainUsed; }
	134	Int_t GetFirstRunVdriftUsed() const { return fFirstRunVdriftUsed; }
	135	Int_t GetVersionVdriftUsed() const { return fVersionVdriftUsed; }
	136	Int_t GetSubVersionVdriftUsed() const { return fSubVersionVdriftUsed; }
	137	Int_t GetFirstRunExBUsed() const { return fFirstRunExBUsed; }
	138	Int_t GetVersionExBUsed() const { return fVersionExBUsed; }
	139	Int_t GetSubVersionExBUsed() const { return fSubVersionExBUsed; }
	140
	141
	142	// Internal functions
b3fcfd96	143
b3fcfd96	144	void CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
a0bb5615	145	void CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
b3fcfd96	146	void CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
b3fcfd96	147	void CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
83d0cc79	148	void CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
81a5aeca	149
83d0cc79	150	Bool_t ReadStatusGlobal(const Char_t* fileName="CalibObjects.root");
b3fcfd96	151	Bool_t ReadGainGlobal(const Char_t* fileName="CalibObjects.root");
	152	Bool_t ReadVdriftT0Global(const Char_t* fileName="CalibObjects.root");
	153	Bool_t ReadVdriftLinearFitGlobal(const Char_t* fileName="CalibObjects.root");
a0bb5615	154	Bool_t ReadExbAltFitGlobal(const Char_t* fileName="CalibObjects.root");
b3fcfd96	155	Bool_t ReadPRFGlobal(const Char_t* fileName="CalibObjects.root");
	156
	157	Bool_t AnalyzeGain();
	158	Bool_t AnalyzeVdriftT0();
	159	Bool_t AnalyzeVdriftLinearFit();
a0bb5615	160	Bool_t AnalyzeExbAltFit();
a5dcf618	161	Bool_t AnalyzePRF();
a5dcf618	162	Bool_t AnalyzeChamberStatus();
b3fcfd96	163
01239968	164	void CorrectFromDetGainUsed();
4c865c34	165	void CorrectFromDetVdriftUsed();
a5dcf618	166
b3fcfd96	167	void UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
b3fcfd96	168	void UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
eec29d56	169	void UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
a0bb5615	170	void UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
b3fcfd96	171	void UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
b3fcfd96	172	void UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
a5dcf618	173	void UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
b3fcfd96	174
54f2ff1c	175	Bool_t ValidateGain();
00d203b6	176	Bool_t ValidateVdrift();
840ec79d	177	Bool_t ValidateExB();
00d203b6	178	Bool_t ValidateT0();
00d203b6	179	Bool_t ValidatePRF() const;
82b413fd	180	Bool_t ValidateChamberStatus();
00d203b6	181
82b413fd	182	Int_t GetStatus() const;
	183	Int_t GetStatusPos() const { return fStatusPos; }
	184	Int_t GetStatusNeg() const { return fStatusNeg; }
a5dcf618	185
83d0cc79	186
4c865c34	187
4c865c34	188	private:
81a5aeca	189	Bool_t fMethodSecond; // Second Method for drift velocity
	190	TString fNameList; // Name of the list
	191	AliTRDCalDet *fCalDetGainUsed; // CalDet used and to be corrected for
	192	AliTRDCalDet *fCalDetVdriftUsed; // CalDet used and to be corrected for
840ec79d	193	AliTRDCalDet *fCalDetExBUsed; // CalDet used and to be corrected for
81a5aeca	194	TH2I *fCH2d; // Gain
	195	TProfile2D *fPH2d; // Drift velocity first method
	196	TProfile2D *fPRF2d; // PRF
83d0cc79	197	THnSparseI *fSparse; // chamberstatus
b3fcfd96	198	AliTRDCalibraVdriftLinearFit *fAliTRDCalibraVdriftLinearFit; // Drift velocity second method
a0bb5615	199	AliTRDCalibraExbAltFit* fAliTRDCalibraExbAltFit; //ExB alternative method
b3fcfd96	200	TH1I *fNEvents; // Number of events
	201	TH2F *fAbsoluteGain; // Absolute Gain calibration
	202	TObjArray * fPlots; // array with some plots to check
	203	TObjArray * fCalibObjects; // array with calibration objects
83d0cc79	204	Int_t fFirstRunGainUsed; // first run gain used
4c865c34	205	Int_t fVersionGainUsed; // VersionGainUsed
4c865c34	206	Int_t fSubVersionGainUsed; // SubVersionGainUsed
ca7e6e64	207	Int_t fFirstRunVdriftUsed; // FirstRunVdrift
4c865c34	208	Int_t fVersionVdriftUsed; // VersionVdriftUsed
4c865c34	209	Int_t fSubVersionVdriftUsed; // SubVersionVdriftUsed
83d0cc79	210	Int_t fFirstRunExBUsed; // FirstRunExB
	211	Int_t fVersionExBUsed; // VersionExBUsed
	212	Int_t fSubVersionExBUsed; // SubVersionExBUsed
	213	Bool_t fNoExBUsedInReco; // ExB not used yet in the reco
00d203b6	214	Bool_t fSwitchOnValidation; // Validation
00d203b6	215	Bool_t fVdriftValidated; // Vdrift validation
840ec79d	216	Bool_t fExBValidated; // ExB validation
00d203b6	217	Bool_t fT0Validated; // T0 validation
a2a4ec8e	218	Int_t fMinStatsVdriftT0PH; // MinStats VdriftT0
	219	Int_t fMinStatsVdriftLinear; // MinStats Vdrift Linear
	220	Int_t fMinStatsGain; // MinStats Gain
	221	Int_t fMinStatsPRF; // MinStats PRF
83d0cc79	222	Int_t fMinStatsChamberStatus; // MinStats ChamberStatus
17aa2935	223	Double_t fMinSingleStatsChamberStatus; // MinStats per chamber in % of mean (ChamberStatus)
54f2ff1c	224	Bool_t fBackCorrectGain; // Back correction afterwards gain
	225	Bool_t fBackCorrectVdrift; // Back correction afterwards vdrift
	226	Bool_t fNotEnoughStatisticsForTheGain;// Take the chamber per chamber distribution from the default distribution
	227	Bool_t fNotEnoughStatisticsForTheVdriftLinear;// Take the chamber per chamber distribution from the default distribution
82b413fd	228	Int_t fStatusNeg; // Info but ok
82b413fd	229	Int_t fStatusPos; // Problems
83d0cc79	230	Int_t fBadCalib[18]; // number of bad calibrated chambers per sm
	231	Int_t fNoData[18]; // number of chambers w/o data per sm
	232	Int_t fBadCalibValidate; // validation limit for bad calibrated chambers
	233	Int_t fNoDataValidate; // validation limit for chamber w/o data (sm w/o data excluded)
	234	Double_t fRMSBadCalibratedGain; // value to decide when it is bad calibrated
	235	Double_t fRMSBadCalibratedVdrift; // value to decide when it is bad calibrated
	236	Double_t fRMSBadCalibratedExB; // value to decide when it is bad calibrated
2a1a7b36	237	Bool_t fRobustFitDriftVelocity; // Robust fit for the drift velocity
2a1a7b36	238	Bool_t fRobustFitExbAlt; // Robust fit for the exb alt
661c7be6	239	Bool_t fAlternativeVdrfitFit; // Alternative fitting method for vdrift calibration
661c7be6	240	Bool_t fAlternativeExbAltFit; // Alternative fitting method for the alternative exb calibarion method
b3fcfd96	241
4c865c34	242	Int_t GetSubVersion(TString name) const;
4c865c34	243	Int_t GetVersion(TString name) const;
ca7e6e64	244	Int_t GetFirstRun(TString name) const;
b3fcfd96	245
	246
	247
	248	private:
	249	AliTRDPreprocessorOffline& operator=(const AliTRDPreprocessorOffline&); // not implemented
	250	AliTRDPreprocessorOffline(const AliTRDPreprocessorOffline&); // not implemented
2a1a7b36	251	ClassDef(AliTRDPreprocessorOffline,3)
b3fcfd96	252	};
	253
	254	#endif
01239968	255
a5dcf618	256