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