[u/mrichter/AliRoot.git] / TPC / AliTPCcalibDButil.h

#ifndef ALITPCCALIBDBUTIL_H
#define ALITPCCALIBDBUTIL_H

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

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class providing the calculation of derived quantities (mean,rms,fits,...) //
//       of calibration entries                                              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <TObject.h>
class TArrayI;
#include <TVectorDfwd.h>
#include <TVectorFfwd.h>

class TGraph;
class TMap;
class AliDCSSensorArray;
class AliTPCcalibDB;
class AliTPCCalPad;
class AliTPCCalROC;
class AliTPCmapper;
class AliTPCCalibRaw;
class AliCDBEntry;
class AliDCSSensor;
class AliDCSSensorArray;
class AliTPCSensorTempArray;
class AliTPCdataQA;
class TGraphErrors;
class TTreeSRedirector;
class AliTPCCalROC;


class AliTPCcalibDButil : public TObject
{
public:
  AliTPCcalibDButil();
  virtual ~AliTPCcalibDButil();

  void UpdateFromCalibDB();
  //data processing functions
  void ProcessCEdata(const char* fitFormula, TVectorD &fitResultsA, TVectorD &fitResultsC,
                     Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad * const outCE=0);
  void ProcessCEgraphs(TVectorD &vecTEntries, TVectorD &vecTMean, TVectorD &vecTRMS, TVectorD &vecTMedian,
                       TVectorD &vecQEntries, TVectorD &vecQMean, TVectorD &vecQRMS, TVectorD &vecQMedian,
                       Float_t &driftTimeA, Float_t &driftTimeC );
  void ProcessNoiseData(TVectorD &vNoiseMean, TVectorD &vNoiseMeanSenRegions,
                        TVectorD &vNoiseRMS, TVectorD &vNoiseRMSSenRegions,
                        Int_t &nonMaskedZero, Int_t &nNaN);
  void ProcessPulser(TVectorD &vMeanTime);
  void ProcessALTROConfig(Int_t &nMasked);
  void ProcessGoofie(TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS);
  
  //processing functions using reference data
  void ProcessPedestalVariations(TVectorF &pedestalDeviations);
  void ProcessNoiseVariations(TVectorF &noiseDeviations);
  void ProcessPulserVariations(TVectorF &pulserQdeviations, Float_t &varQMean, Int_t &npadsOutOneTB, Int_t &npadsOffAdd);
  
  //getter preprocess information
  Int_t GetNPulserOutliers() const {return fNpulserOutliers;}
  Float_t GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC * const rocOut=0x0);
  AliTPCCalPad *GetPulserOutlierMap() const {return fPulserOutlier;}

  //getters ref data
  TMap *GetReferenceMap() const {return fRefMap;}
  Int_t GetReferenceRun(const char* type) const;
  const char* GetRefValidity() const {return fRefValidity.Data();}
  
  AliTPCCalPad* GetRefPadNoise() const {return fRefPadNoise;}
  AliTPCCalPad* GetRefPedestals() const {return fRefPedestals;}
  AliTPCCalPad* GetRefPedestalMasked() const {return fRefPedestalMasked;}
  AliTPCCalPad* GetRefPulserTmean() const {return fRefPulserTmean;}
  AliTPCCalPad* GetRefPulserTrms() const {return fRefPulserTrms;}
  AliTPCCalPad* GetRefPulserQmean() const {return fRefPulserQmean;}
  AliTPCCalPad* GetRefPulserOutlier() const {return fRefPulserOutlier;}
  AliTPCCalPad* GetRefPulserMasked() const {return fRefPulserMasked;}
  AliTPCCalPad* GetRefCETmean() const {return fRefCETmean;}
  AliTPCCalPad* GetRefCETrms() const {return fRefCETrms;}
  AliTPCCalPad* GetRefCEQmean() const {return fRefCEQmean;}
  AliTPCCalPad* GetRefCEMasked() const {return fRefCEMasked;}
  AliTPCCalPad* GetRefALTROFPED() const {return fRefALTROFPED;}
  AliTPCCalPad* GetRefALTROZsThr() const {return fRefALTROZsThr;}
  AliTPCCalPad* GetRefALTROAcqStart() const {return fRefALTROAcqStart;}
  AliTPCCalPad* GetRefALTROAcqStop() const {return fRefALTROAcqStop;}
  AliTPCCalPad* GetRefALTROMasked() const {return fRefALTROMasked;}
  
  
  //setters for pad by pad information
  void SetPulserData(AliTPCCalPad * const tmean, AliTPCCalPad * const trms=0x0, AliTPCCalPad * const qmean=0x0)
                {fPulserTmean=tmean; fPulserTrms=trms; fPulserQmean=qmean;}
  void SetCEData(AliTPCCalPad *const tmean, AliTPCCalPad *const trms=0x0, AliTPCCalPad *const qmean=0x0)
                {fCETmean=tmean; fCETrms=trms; fCEQmean=qmean;}
  void SetNoisePedestal(AliTPCCalPad *const noise, AliTPCCalPad *const pedestal=0x0)
                {fPadNoise=noise; fPedestals=pedestal;}
  void SetALTROData(AliTPCCalPad *const masked)
                {fALTROMasked=masked;}
  void SetGoofieArray(AliDCSSensorArray *const arr) {fGoofieArray=arr;}
  
  //setters for pad by pad information
  void SetRefFile(const char* filename);
  void SetReferenceRun(Int_t run=-1);
  void UpdateRefDataFromOCDB();
  void SetRefPulserData(AliTPCCalPad *const tmean, AliTPCCalPad *const trms=0x0, AliTPCCalPad *const qmean=0x0)
                {fRefPulserTmean=tmean; fRefPulserTrms=trms; fRefPulserQmean=qmean;}
  void SetRefCEData(AliTPCCalPad *const tmean, AliTPCCalPad *const trms=0x0, AliTPCCalPad *const qmean=0x0)
                {fRefCETmean=tmean; fRefCETrms=trms; fRefCEQmean=qmean;}
  void SetRefNoisePedestal(AliTPCCalPad *const noise, AliTPCCalPad *const pedestal=0x0)
                {fRefPadNoise=noise; fRefPedestals=pedestal;}
  void SetRefALTROData(AliTPCCalPad *const masked)
                {fRefALTROMasked=masked;}
  
  //creation of derived pad by pad calibration data
  AliTPCCalPad *CreatePadTime0(Int_t model, Double_t &gyA, Double_t &gyC, Double_t &chi2A, Double_t &chi2C);
  //
  // create outlyer maps
  //
  AliTPCCalPad *CreateCEOutlyerMap(Int_t &noutliersCE, AliTPCCalPad * const ceOut=0, Float_t minSignal=10, Float_t cutTrmsMin=0.9, Float_t cutTrmsMax=1.2, Float_t cutMaxDistT=0.7);
  AliTPCCalPad *CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad * const pulserOut=0, Float_t cutTime=3, Float_t cutnRMSQ=5, Float_t cutnRMSrms=5);
  //
  AliTPCCalPad *CreatePadTime0CE(TVectorD &fitResultsA, TVectorD&fitResultsC, Int_t &nOut, Double_t &chi2A, Double_t &chi2C, const char *dumpfile=0);
  //

  void UpdatePulserOutlierMap();
  void UpdateRefPulserOutlierMap();
  void PulserOutlierMap(AliTPCCalPad *pulOut, const AliTPCCalPad *pulT, const AliTPCCalPad *pulQ);

  const char* GetGUIRefTreeDefaultName();
  
  Bool_t CreateGUIRefTree(const char* filename="");
  //
  // graph tools
  //
  static Double_t GetLaserTime0(Int_t run, Int_t timeStamp, Int_t deltaT, Int_t side);
  static TGraph* FilterGraphMedian(TGraph * const graph, Float_t sigmaCut, Double_t &medianY);
  static TGraph* FilterGraphMedianAbs(TGraph * graph, Float_t cut, Double_t &medianY);
  static TGraphErrors* FilterGraphMedianErr(TGraphErrors * graph, Float_t sigmaCut,Double_t &medianY);
  //
  static void Sort(TGraph *graph);
  static void SmoothGraph(TGraph *graph, Double_t delta);
  static Int_t     GetNearest(TGraph *graph, Double_t xref, Double_t &dx, Double_t &y);
  static Double_t EvalGraphConst(TGraph * const graph, Double_t xref);
  //
  // Filter sensors
  //
  static Float_t FilterSensor(AliDCSSensor * sensor, Double_t ymin, Double_t ymax, Double_t maxdy, Double_t sigmaCut); 
  //
  // Filter AliRelAlignmentKalman - Alignment/Drift velocity
  //
  static TMatrixD* MakeStatRelKalman(TObjArray * const array, Float_t minFraction, Int_t minStat, Float_t maxvd);
  static TObjArray *SmoothRelKalman(TObjArray * const array,const TMatrixD & stat, Bool_t direction, Float_t sigmaCut);
  static TObjArray *SmoothRelKalman(TObjArray * const arrayP, TObjArray * const arrayM);
  static void FilterCE(Double_t deltaT=100, Double_t cutAbs=10, Double_t cutSigma=4., TTreeSRedirector * const pcstream=0);
  static void FilterTracks(Int_t run, Double_t cutSigma=20., TTreeSRedirector * const pcstream=0);
  static Float_t FilterTemperature(AliTPCSensorTempArray *tempArray, Double_t ymin=15, Double_t ymax=22, Double_t sigmaCut=5); 

  static   void FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT=2, Double_t cutSigma=4.,  Double_t minVdn=8.5, Double_t maxVdn=9.05, TTreeSRedirector * const pcstream=0);
  static Double_t  GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT=86400, Double_t deltaTLaser=3600, Int_t valType=0);
  static Double_t  GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT=86400, Double_t deltaTLaser=3600, Int_t valType=0);
  static Double_t  GetVDriftTPCLaserTracks(Double_t &dist,Int_t run, Int_t timeStamp, Double_t deltaT=43200, Int_t side=2);
  static Double_t  GetVDriftTPCCE(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT=43200, Int_t side=2);
  static Double_t  GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t timeStamp);
  static Double_t  GetTime0TPCITS(Double_t &dist, Int_t run, Int_t timeStamp);
  Int_t MakeRunList(Int_t startRun, Int_t stopRun); // find the list of usable runs
  Int_t FindRunTPC(Int_t    itime, Bool_t debug=kFALSE);
private:
  AliTPCcalibDB *fCalibDB;            //pointer to calibDB object
  AliTPCCalPad  *fPadNoise;           //noise information
  AliTPCCalPad  *fPedestals;          //pedestal information
  AliTPCCalPad  *fPulserTmean;        //pulser mean time information 
  AliTPCCalPad  *fPulserTrms;         //pulser rms time information
  AliTPCCalPad  *fPulserQmean;        //pulser mean q information
  AliTPCCalPad  *fPulserOutlier;      //pulser outlier map
  AliTPCCalPad  *fCETmean;            //central electrode mean time information
  AliTPCCalPad  *fCETrms;             //central electrode rms time information
  AliTPCCalPad  *fCEQmean;            //central electrode mean q information
  AliTPCCalPad  *fALTROMasked;        //ALTRO masked channels information
  //
  AliTPCCalibRaw *fCalibRaw;          //raw calibration object
  //
  AliTPCdataQA   *fDataQA;            //data qa
  //reference data
  TMap *fRefMap;                        // latest map to reference information
  TMap *fCurrentRefMap;                 // reference data map of entries currently loaded
  TString fRefValidity;                 // validity range of reference data
  //  
  AliTPCCalPad  *fRefPadNoise;           //Reference noise information
  AliTPCCalPad  *fRefPedestals;          //Reference pedestal information
  AliTPCCalPad  *fRefPedestalMasked;     //Reference masked channels in pedestal run
  AliTPCCalPad  *fRefPulserTmean;        //Reference pulser mean time information
  AliTPCCalPad  *fRefPulserTrms;         //Reference pulser rms time information
  AliTPCCalPad  *fRefPulserQmean;        //Reference pulser mean q information
  AliTPCCalPad  *fRefPulserOutlier;      //Reference pulser outlier map
  AliTPCCalPad  *fRefPulserMasked;       //Reference masked channels in pulser run
  AliTPCCalPad  *fRefCETmean;            //Reference central electrode mean time information
  AliTPCCalPad  *fRefCETrms;             //Reference central electrode rms time information
  AliTPCCalPad  *fRefCEQmean;            //Reference central electrode mean q information
  AliTPCCalPad  *fRefCEMasked;           //Reference masked channels in laser run
  AliTPCCalPad  *fRefALTROFPED;          //Reference fixed pedestal value
  AliTPCCalPad  *fRefALTROZsThr;         //Reference zero suppression threshol
  AliTPCCalPad  *fRefALTROAcqStart;      //Reference accquistion start time bin
  AliTPCCalPad  *fRefALTROAcqStop;       //Reference accquistion stop time bin
  AliTPCCalPad  *fRefALTROMasked;        //Reference ALTRO masked channels information
  //
  AliTPCCalibRaw *fRefCalibRaw;          //Reference raw calibration object
  //
  AliTPCdataQA   *fRefDataQA;            //Reference data QA
  //
  AliDCSSensorArray* fGoofieArray;    //Goofie Data
  //
  AliTPCmapper  *fMapper;             //TPC mapping handler
  Int_t fNpulserOutliers;             //number of outliers from Pulser calibration
  
  Float_t fIrocTimeOffset;               //timing offset between IROC and OROC in timebins
  Float_t fCETmaxLimitAbs;               //maximum variation in CE data before pads will be treated as outliers
  Float_t fPulTmaxLimitAbs;              //maximum variation of Pulser Signals (time) before pads will be treated as outliers
  Float_t fPulQmaxLimitAbs;              //maximum variation of Pulser Signals (charge) before pads will be treated as outliers
  Float_t fPulQminLimit;                 //minimum charge value for Pulser Signals before pads will be treated as outliers

  //
  // helpers to get the run number for given time stamps
  //
  // filters  
  
  TArrayI fRuns;                         // run list with OCDB info
  TArrayI fRunsStart;                    // start time for given run
  TArrayI fRunsStop;                     // stop time for given run
  
  AliTPCcalibDButil (const AliTPCcalibDButil& );
  AliTPCcalibDButil& operator= (const AliTPCcalibDButil& );

  AliTPCCalPad* GetRefCalPad(AliCDBEntry *entry, const char* objName);
  AliTPCCalPad* GetRefCalPad(AliCDBEntry *entry);
  AliTPCCalPad* GetAltroMasked(const char* cdbPath, const char* name);
  Bool_t HasRefChanged(const char *cdbPath);
  Int_t GetCurrentReferenceRun(const char* type) const;
  AliCDBEntry* GetRefEntry(const char* cdbPath);
  
  ClassDef(AliTPCcalibDButil,0)
};


#endif
Commit	Line	Data
8166d5d7	1	#ifndef ALITPCCALIBDBUTIL_H
8166d5d7	2	#define ALITPCCALIBDBUTIL_H
892226be	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 providing the calculation of derived quantities (mean,rms,fits,...) //
	10	// of calibration entries //
	11	// //
	12	///////////////////////////////////////////////////////////////////////////////
	13
	14	#include <TObject.h>
98a4cc77	15	class TArrayI;
	16	#include <TVectorDfwd.h>
	17	#include <TVectorFfwd.h>
892226be	18
949d8707	19	class TGraph;
949d8707	20	class TMap;
892226be	21	class AliDCSSensorArray;
	22	class AliTPCcalibDB;
	23	class AliTPCCalPad;
37f2177e	24	class AliTPCCalROC;
892226be	25	class AliTPCmapper;
6e7d7dc4	26	class AliTPCCalibRaw;
949d8707	27	class AliCDBEntry;
37f2177e	28	class AliDCSSensor;
	29	class AliDCSSensorArray;
	30	class AliTPCSensorTempArray;
949d8707	31	class AliTPCdataQA;
a23ba1c3	32	class TGraphErrors;
a23ba1c3	33	class TTreeSRedirector;
37f2177e	34	class AliTPCCalROC;
8166d5d7	35
8166d5d7	36
892226be	37	class AliTPCcalibDButil : public TObject
	38	{
	39	public:
	40	AliTPCcalibDButil();
	41	virtual ~AliTPCcalibDButil();
	42
	43	void UpdateFromCalibDB();
	44	//data processing functions
7390f655	45	void ProcessCEdata(const char* fitFormula, TVectorD &fitResultsA, TVectorD &fitResultsC,
8166d5d7	46	Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad * const outCE=0);
892226be	47	void ProcessCEgraphs(TVectorD &vecTEntries, TVectorD &vecTMean, TVectorD &vecTRMS, TVectorD &vecTMedian,
	48	TVectorD &vecQEntries, TVectorD &vecQMean, TVectorD &vecQRMS, TVectorD &vecQMedian,
	49	Float_t &driftTimeA, Float_t &driftTimeC );
	50	void ProcessNoiseData(TVectorD &vNoiseMean, TVectorD &vNoiseMeanSenRegions,
	51	TVectorD &vNoiseRMS, TVectorD &vNoiseRMSSenRegions,
93425263	52	Int_t &nonMaskedZero, Int_t &nNaN);
892226be	53	void ProcessPulser(TVectorD &vMeanTime);
	54	void ProcessALTROConfig(Int_t &nMasked);
	55	void ProcessGoofie(TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS);
949d8707	56
7390f655	57	//processing functions using reference data
	58	void ProcessPedestalVariations(TVectorF &pedestalDeviations);
	59	void ProcessNoiseVariations(TVectorF &noiseDeviations);
	60	void ProcessPulserVariations(TVectorF &pulserQdeviations, Float_t &varQMean, Int_t &npadsOutOneTB, Int_t &npadsOffAdd);
949d8707	61
892226be	62	//getter preprocess information
892226be	63	Int_t GetNPulserOutliers() const {return fNpulserOutliers;}
8166d5d7	64	Float_t GetMeanAltro(const AliTPCCalROC roc, const Int_t row, const Int_t pad, AliTPCCalROC const rocOut=0x0);
892226be	65	AliTPCCalPad *GetPulserOutlierMap() const {return fPulserOutlier;}
949d8707	66
	67	//getters ref data
	68	TMap *GetReferenceMap() const {return fRefMap;}
c95e0219	69	Int_t GetReferenceRun(const char* type) const;
949d8707	70	const char* GetRefValidity() const {return fRefValidity.Data();}
	71
	72	AliTPCCalPad* GetRefPadNoise() const {return fRefPadNoise;}
	73	AliTPCCalPad* GetRefPedestals() const {return fRefPedestals;}
	74	AliTPCCalPad* GetRefPedestalMasked() const {return fRefPedestalMasked;}
	75	AliTPCCalPad* GetRefPulserTmean() const {return fRefPulserTmean;}
	76	AliTPCCalPad* GetRefPulserTrms() const {return fRefPulserTrms;}
	77	AliTPCCalPad* GetRefPulserQmean() const {return fRefPulserQmean;}
	78	AliTPCCalPad* GetRefPulserOutlier() const {return fRefPulserOutlier;}
	79	AliTPCCalPad* GetRefPulserMasked() const {return fRefPulserMasked;}
	80	AliTPCCalPad* GetRefCETmean() const {return fRefCETmean;}
	81	AliTPCCalPad* GetRefCETrms() const {return fRefCETrms;}
	82	AliTPCCalPad* GetRefCEQmean() const {return fRefCEQmean;}
	83	AliTPCCalPad* GetRefCEMasked() const {return fRefCEMasked;}
	84	AliTPCCalPad* GetRefALTROFPED() const {return fRefALTROFPED;}
	85	AliTPCCalPad* GetRefALTROZsThr() const {return fRefALTROZsThr;}
	86	AliTPCCalPad* GetRefALTROAcqStart() const {return fRefALTROAcqStart;}
	87	AliTPCCalPad* GetRefALTROAcqStop() const {return fRefALTROAcqStop;}
	88	AliTPCCalPad* GetRefALTROMasked() const {return fRefALTROMasked;}
	89
	90
892226be	91	//setters for pad by pad information
8166d5d7	92	void SetPulserData(AliTPCCalPad * const tmean, AliTPCCalPad * const trms=0x0, AliTPCCalPad * const qmean=0x0)
892226be	93	{fPulserTmean=tmean; fPulserTrms=trms; fPulserQmean=qmean;}
98a4cc77	94	void SetCEData(AliTPCCalPad const tmean, AliTPCCalPad const trms=0x0, AliTPCCalPad *const qmean=0x0)
892226be	95	{fCETmean=tmean; fCETrms=trms; fCEQmean=qmean;}
98a4cc77	96	void SetNoisePedestal(AliTPCCalPad const noise, AliTPCCalPad const pedestal=0x0)
892226be	97	{fPadNoise=noise; fPedestals=pedestal;}
98a4cc77	98	void SetALTROData(AliTPCCalPad *const masked)
892226be	99	{fALTROMasked=masked;}
98a4cc77	100	void SetGoofieArray(AliDCSSensorArray *const arr) {fGoofieArray=arr;}
949d8707	101
7390f655	102	//setters for pad by pad information
7390f655	103	void SetRefFile(const char* filename);
949d8707	104	void SetReferenceRun(Int_t run=-1);
949d8707	105	void UpdateRefDataFromOCDB();
98a4cc77	106	void SetRefPulserData(AliTPCCalPad const tmean, AliTPCCalPad const trms=0x0, AliTPCCalPad *const qmean=0x0)
7390f655	107	{fRefPulserTmean=tmean; fRefPulserTrms=trms; fRefPulserQmean=qmean;}
98a4cc77	108	void SetRefCEData(AliTPCCalPad const tmean, AliTPCCalPad const trms=0x0, AliTPCCalPad *const qmean=0x0)
7390f655	109	{fRefCETmean=tmean; fRefCETrms=trms; fRefCEQmean=qmean;}
98a4cc77	110	void SetRefNoisePedestal(AliTPCCalPad const noise, AliTPCCalPad const pedestal=0x0)
7390f655	111	{fRefPadNoise=noise; fRefPedestals=pedestal;}
98a4cc77	112	void SetRefALTROData(AliTPCCalPad *const masked)
7390f655	113	{fRefALTROMasked=masked;}
7390f655	114
892226be	115	//creation of derived pad by pad calibration data
2cb269df	116	AliTPCCalPad *CreatePadTime0(Int_t model, Double_t &gyA, Double_t &gyC, Double_t &chi2A, Double_t &chi2C);
892226be	117	//
2cb269df	118	// create outlyer maps
2cb269df	119	//
8166d5d7	120	AliTPCCalPad CreateCEOutlyerMap(Int_t &noutliersCE, AliTPCCalPad const ceOut=0, Float_t minSignal=10, Float_t cutTrmsMin=0.9, Float_t cutTrmsMax=1.2, Float_t cutMaxDistT=0.7);
8166d5d7	121	AliTPCCalPad CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad const pulserOut=0, Float_t cutTime=3, Float_t cutnRMSQ=5, Float_t cutnRMSrms=5);
2cb269df	122	//
	123	AliTPCCalPad CreatePadTime0CE(TVectorD &fitResultsA, TVectorD&fitResultsC, Int_t &nOut, Double_t &chi2A, Double_t &chi2C, const char dumpfile=0);
	124	//
	125
892226be	126	void UpdatePulserOutlierMap();
7390f655	127	void UpdateRefPulserOutlierMap();
7390f655	128	void PulserOutlierMap(AliTPCCalPad pulOut, const AliTPCCalPad pulT, const AliTPCCalPad *pulQ);
817766d5	129
949d8707	130	const char* GetGUIRefTreeDefaultName();
	131
	132	Bool_t CreateGUIRefTree(const char* filename="");
817766d5	133	//
	134	// graph tools
	135	//
a23ba1c3	136	static Double_t GetLaserTime0(Int_t run, Int_t timeStamp, Int_t deltaT, Int_t side);
8166d5d7	137	static TGraph* FilterGraphMedian(TGraph * const graph, Float_t sigmaCut, Double_t &medianY);
a23ba1c3	138	static TGraph* FilterGraphMedianAbs(TGraph * graph, Float_t cut, Double_t &medianY);
	139	static TGraphErrors* FilterGraphMedianErr(TGraphErrors * graph, Float_t sigmaCut,Double_t &medianY);
	140	//
	141	static void Sort(TGraph *graph);
	142	static void SmoothGraph(TGraph *graph, Double_t delta);
817766d5	143	static Int_t GetNearest(TGraph *graph, Double_t xref, Double_t &dx, Double_t &y);
8166d5d7	144	static Double_t EvalGraphConst(TGraph * const graph, Double_t xref);
1e722a63	145	//
	146	// Filter sensors
	147	//
	148	static Float_t FilterSensor(AliDCSSensor * sensor, Double_t ymin, Double_t ymax, Double_t maxdy, Double_t sigmaCut);
a980538f	149	//
	150	// Filter AliRelAlignmentKalman - Alignment/Drift velocity
	151	//
8166d5d7	152	static TMatrixD* MakeStatRelKalman(TObjArray * const array, Float_t minFraction, Int_t minStat, Float_t maxvd);
	153	static TObjArray SmoothRelKalman(TObjArray const array,const TMatrixD & stat, Bool_t direction, Float_t sigmaCut);
	154	static TObjArray SmoothRelKalman(TObjArray const arrayP, TObjArray * const arrayM);
	155	static void FilterCE(Double_t deltaT=100, Double_t cutAbs=10, Double_t cutSigma=4., TTreeSRedirector * const pcstream=0);
	156	static void FilterTracks(Int_t run, Double_t cutSigma=20., TTreeSRedirector * const pcstream=0);
1e722a63	157	static Float_t FilterTemperature(AliTPCSensorTempArray *tempArray, Double_t ymin=15, Double_t ymax=22, Double_t sigmaCut=5);
a23ba1c3	158
8166d5d7	159	static void FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT=2, Double_t cutSigma=4., Double_t minVdn=8.5, Double_t maxVdn=9.05, TTreeSRedirector * const pcstream=0);
a23ba1c3	160	static Double_t GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT=86400, Double_t deltaTLaser=3600, Int_t valType=0);
	161	static Double_t GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT=86400, Double_t deltaTLaser=3600, Int_t valType=0);
	162	static Double_t GetVDriftTPCLaserTracks(Double_t &dist,Int_t run, Int_t timeStamp, Double_t deltaT=43200, Int_t side=2);
	163	static Double_t GetVDriftTPCCE(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT=43200, Int_t side=2);
cc65e4f5	164	static Double_t GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t timeStamp);
cc65e4f5	165	static Double_t GetTime0TPCITS(Double_t &dist, Int_t run, Int_t timeStamp);
a23ba1c3	166	Int_t MakeRunList(Int_t startRun, Int_t stopRun); // find the list of usable runs
a23ba1c3	167	Int_t FindRunTPC(Int_t itime, Bool_t debug=kFALSE);
892226be	168	private:
	169	AliTPCcalibDB *fCalibDB; //pointer to calibDB object
	170	AliTPCCalPad *fPadNoise; //noise information
	171	AliTPCCalPad *fPedestals; //pedestal information
	172	AliTPCCalPad *fPulserTmean; //pulser mean time information
	173	AliTPCCalPad *fPulserTrms; //pulser rms time information
	174	AliTPCCalPad *fPulserQmean; //pulser mean q information
	175	AliTPCCalPad *fPulserOutlier; //pulser outlier map
	176	AliTPCCalPad *fCETmean; //central electrode mean time information
	177	AliTPCCalPad *fCETrms; //central electrode rms time information
	178	AliTPCCalPad *fCEQmean; //central electrode mean q information
	179	AliTPCCalPad *fALTROMasked; //ALTRO masked channels information
	180	//
6e7d7dc4	181	AliTPCCalibRaw *fCalibRaw; //raw calibration object
949d8707	182	//
949d8707	183	AliTPCdataQA *fDataQA; //data qa
7390f655	184	//reference data
949d8707	185	TMap *fRefMap; // latest map to reference information
	186	TMap *fCurrentRefMap; // reference data map of entries currently loaded
	187	TString fRefValidity; // validity range of reference data
	188	//
7390f655	189	AliTPCCalPad *fRefPadNoise; //Reference noise information
7390f655	190	AliTPCCalPad *fRefPedestals; //Reference pedestal information
949d8707	191	AliTPCCalPad *fRefPedestalMasked; //Reference masked channels in pedestal run
7390f655	192	AliTPCCalPad *fRefPulserTmean; //Reference pulser mean time information
	193	AliTPCCalPad *fRefPulserTrms; //Reference pulser rms time information
	194	AliTPCCalPad *fRefPulserQmean; //Reference pulser mean q information
	195	AliTPCCalPad *fRefPulserOutlier; //Reference pulser outlier map
949d8707	196	AliTPCCalPad *fRefPulserMasked; //Reference masked channels in pulser run
7390f655	197	AliTPCCalPad *fRefCETmean; //Reference central electrode mean time information
	198	AliTPCCalPad *fRefCETrms; //Reference central electrode rms time information
	199	AliTPCCalPad *fRefCEQmean; //Reference central electrode mean q information
949d8707	200	AliTPCCalPad *fRefCEMasked; //Reference masked channels in laser run
	201	AliTPCCalPad *fRefALTROFPED; //Reference fixed pedestal value
	202	AliTPCCalPad *fRefALTROZsThr; //Reference zero suppression threshol
	203	AliTPCCalPad *fRefALTROAcqStart; //Reference accquistion start time bin
	204	AliTPCCalPad *fRefALTROAcqStop; //Reference accquistion stop time bin
7390f655	205	AliTPCCalPad *fRefALTROMasked; //Reference ALTRO masked channels information
	206	//
	207	AliTPCCalibRaw *fRefCalibRaw; //Reference raw calibration object
949d8707	208	//
949d8707	209	AliTPCdataQA *fRefDataQA; //Reference data QA
6e7d7dc4	210	//
892226be	211	AliDCSSensorArray* fGoofieArray; //Goofie Data
	212	//
	213	AliTPCmapper *fMapper; //TPC mapping handler
	214	Int_t fNpulserOutliers; //number of outliers from Pulser calibration
	215
	216	Float_t fIrocTimeOffset; //timing offset between IROC and OROC in timebins
	217	Float_t fCETmaxLimitAbs; //maximum variation in CE data before pads will be treated as outliers
	218	Float_t fPulTmaxLimitAbs; //maximum variation of Pulser Signals (time) before pads will be treated as outliers
	219	Float_t fPulQmaxLimitAbs; //maximum variation of Pulser Signals (charge) before pads will be treated as outliers
	220	Float_t fPulQminLimit; //minimum charge value for Pulser Signals before pads will be treated as outliers
a23ba1c3	221
	222	//
	223	// helpers to get the run number for given time stamps
	224	//
	225	// filters
892226be	226
a23ba1c3	227	TArrayI fRuns; // run list with OCDB info
	228	TArrayI fRunsStart; // start time for given run
	229	TArrayI fRunsStop; // stop time for given run
8166d5d7	230
892226be	231	AliTPCcalibDButil (const AliTPCcalibDButil& );
	232	AliTPCcalibDButil& operator= (const AliTPCcalibDButil& );
	233
949d8707	234	AliTPCCalPad* GetRefCalPad(AliCDBEntry entry, const char objName);
	235	AliTPCCalPad* GetRefCalPad(AliCDBEntry *entry);
	236	AliTPCCalPad* GetAltroMasked(const char* cdbPath, const char* name);
	237	Bool_t HasRefChanged(const char *cdbPath);
c95e0219	238	Int_t GetCurrentReferenceRun(const char* type) const;
949d8707	239	AliCDBEntry* GetRefEntry(const char* cdbPath);
949d8707	240
892226be	241	ClassDef(AliTPCcalibDButil,0)
	242	};
	243
	244
	245	#endif