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


#ifndef ALITPCMONITOR_H
#define ALITPCMONITOR_H

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

/* $Id$ */


////////////////////////////////////////////////////////////////////////
//
// AliTPCMonitor class
// 
// Main class for TPC Monitor
// Monitor can handle rootified data, files and online streams in DATE format.
// The monitor GUI is started by the macro TPCMonitor.C
// 
// Author: Stefan Kniege, IKF, Frankfurt
//       
//
/////////////////////////////////////////////////////////////////////////

 
#include <stdio.h>
#include <fstream>
#include <stdlib.h>
#include <iostream>
#include <istream>
#include <ostream>
#include "TStyle.h"
#include "TSystem.h"
#include "TH2F.h"
#include "TLegend.h"
#include "TF1.h"
#include "TMath.h"
#include "TFormula.h"
#include <string>
#include "TROOT.h"
#include "TCanvas.h"
#include "TApplication.h"
#include "TGaxis.h"
#include "TPaveText.h"
#include "TGButtonGroup.h"
#include "TGButton.h"
#include "TGTextBuffer.h"
#include "TGTextEntry.h"
#include "TGLabel.h"
#include "TH3S.h"
#include "AliTPCMonitorMappingHandler.h"
#include "AliTPCMonitorDateFile.h"
#include "AliTPCMonitorDateFormat.h"
#include "AliTPCMonitorAltro.h"
#include "AliTPCMonitorFFT.h"
#include "AliTPCMonitorConfig.h"
#include "AliSignalProcesor.h"
#include "AliRawReaderRoot.h"
#include "AliRawReader.h"
#include "TGMsgBox.h"
#include "TNamed.h"
#include "TObject.h" 
#include "TDirectory.h"
#include "AliLog.h"
#include "RQ_OBJECT.h"

class AliTPCMonitorDateMonitor;

using namespace std;

class AliTPCMonitor : public AliTPCMonitorConfig {
    
 public:
    
    AliTPCMonitor(char* name, char* title);
    virtual ~AliTPCMonitor();
    
    // stats for size of arrays and histograms /////////////////////////////////////////////////
    Int_t**      fPad;                      // array to store channel adc in time    
    Float_t*     fPadMapHw;                 // array to store mapping of hardware address and channel number
    Int_t**      fPadMapRCU;                // store multiple information for hardware address for debugging purpose (read out errors occur)
     
        
    // histograms to be used      ////////////////////////////////////////////////////////////////
    TH2F*        fHistIROC;                 // histo for max adc IROC
    TH2F*        fHistOROC;                 // histo for max adc OROC
    TH2S*        fHistIROCIndex;            // histo for channel number in each bin IROC
    TH2S*        fHistOROCIndex;            // histo for channel number in each bin OROC
    TH2F*        fHistIROCTime;             // histo for peaking time in each bin IROC
    TH2F*        fHistOROCTime;             // histo for peaking time in each bin OROC
    TH2F*        fHistIROCClone;            // clone histo for max adc IROC (backup when selecting component)
    TH2F*        fHistOROCClone;            // clone histo for max adc OROC (backup when selecting component)
    TH2F*        fHistIROCRMS;              // histo for RMS IROC
    TH2F*        fHistOROCRMS;              // histo for RMS OROC
    TH2F*        fHistIROCBASE;             // histo for baseline IROC
    TH2F*        fHistOROCBASE;             // histo for baseline OROC
    TH2F*        fHistIROCSUM;              // histo for adc sum IROC
    TH2F*        fHistOROCSUM;              // histo for adc sum OROC
    
    TH2F*        fHistChannelTime;          // histo for adc(channel,time)
    TH1F*        fHistAddrMapIndex;         // histo for channel(hardware address)        
    TH1F*        fHistAddrMaxAdc;           // histo for max-adc(hardware address)
    TH1F*        fHistAddrBaseMean;         // histo for baseline(hardware address)
    TH1F*        fHistAddrMaxAdcX;          // histo for max-adc-xposition(hardware address)
    TH1F*        fHistAddrAdcSum;           // histo for adc-sum(hardware address)
    TH1F*        fHistAddrBaseRms;          // histo for baselinr-rms(hardware address)
  
    TH1F*        fHistDistrSumIROC;         // distribution of adc sum for all channels IROC
    TH1F*        fHistDistrMaxIROC;         // distribution of adc max for all channels OROC
    TH1F*        fHistDistrSumOROC;         // distribution of adc sum for all channels OROC
    TH1F*        fHistDistrMaxOROC;         // distribution of adc max for all channels OROC
        
    TH2F*        fHistDistrBase2dIROC;      // distribution of baseline vs rms for all channels IROC
    TH2F*        fHistDistrBase2dOROC;      // distribution of baseline vs rms for all channels OROC
    TH1D*        fHistDistrBaseRmsIROC;     // projection of fHistDistrBase2dIROC on Rms
    TH1D*        fHistDistrBaseMeanIROC;    // projection of fHistDistrBase2dIROC on Mean
    TH1D*        fHistDistrBaseRmsOROC;     // projection of fHistDistrBase2dOROC on Rms
    TH1D*        fHistDistrBaseMeanOROC;    // projection of fHistDistrBase2dOROC on Mean

    TH2S*        fHistGlobalMaxA;           // global histogramm for max adc of all sectors Side A
    TH2S*        fHistGlobalMaxC;           // global histogramm for max adc of all sectors Side C
    
    TObjArray*   fHistList;                 // array to store all histogram 

    
    // row and pad settings 
    Int_t        kNRowsIroc;                // number of rows in IROC
    Int_t        kNRowsOroc;                // number of rows in OROC
    
    Int_t        kNPadsIroc;                // number of pads in IROC
    Int_t        kNPadsOroc;                // number of pads in OROC
    
    Int_t        kNPadMinIroc;              // min for pad (y-axis) representation in 2D histogram IROC
    Int_t        kNPadMinOroc;              // min for pad (y-axis) representation in 2D histogram OROC
    Int_t        kNPadMaxIroc;              // max for pad (y-axis) representation in 2D histogram IROC
    Int_t        kNPadMaxOroc;              // max for pad (y-axis) representation in 2D histogram IROC

    Int_t        fVerb;                     // verbose flag
    
    Int_t        fLastEv;                   // flag for last event 
    
    Int_t        fEventNumber;              // current event number (ID)
    Int_t        fEventNumberOld;           // previous event number
    
    Int_t        fDisableFit;               // flag to disable fit of maximum  peak
    
    Int_t        fExecGlob;                 // flag to add Executable to global histo
    Int_t        fExecPlaneMax;             // flag to add executable for plane view ( max iroc/oroc)            
    Int_t        fExecPadIrocRms;           // flag to add executable for rms plane view IROC
    Int_t        fExecPadOrocRms;           // flag to add executable for rms plane view OROC
    
    Int_t        fRunId;                    // current run id
    Int_t        fEqId;                     // currend equipment id
    
    Int_t        fPadUsedRoc;               // last ROC canvas the mouse pointed at 
    Int_t        fPadUsedHwAddr;            // hwaddress for last pad the mouse pointed at 

    Int_t        fGdcId;                    // current GDC id
    Int_t        fLdcId;                    // current LDC id 
    Int_t        fLdcIdOld;                 // previous LDC id
    
    Int_t**      fMapEqidsSec;              // mapping rcu-patch(equipmentid)
    Int_t*       fMapEqidsRcu;              // mapping equipmentid(sector,rcu-patch)

    Int_t        fMirror;                   // mirror x position on C-side
    Int_t        fChannelIter;              // counter for channels read


    AliTPCMonitorMappingHandler*  fMapHand;            // mapping handler   
    
    AliRawReaderRoot*             fReaderROOT;         // reader for ROOT format
    AliTPCMonitorDateFile*        fReaderDATE;         // reader for DATE files

    AliTPCMonitorDateMonitor*     fReaderDATEMon;      // reader for DATE monitoring
    

    Int_t         CheckEqId(Int_t secid, Int_t eqid);
    TCanvas*      CreateCanvas(char* name);
    void          CreateHistos();
    
    void          DeleteHistos();
    void          DisableFit(Int_t val) { fDisableFit =val; }
    void          DrawHists(Int_t histos);
    void          DrawRMSMap();
    void          DumpHeader(AliRawReaderRoot*          reader  );
    void          DumpHeader(AliTPCMonitorDateFormat*   DateForm);
    
    void          ExecPad() ;
    void          ExecRow() ;
    Int_t         ExecProcess();
    void          ExecTransform();
    
    void          FillGlobal(Int_t sector);
    void          FillHistsDecode( AliTPCMonitorAltro* altro , Int_t rcu_patch, Int_t id=0);
    void          FillHistsPadPlane();
    
    static double Gamma4(double* x, double* par);
    Int_t         GetChannelsProc()   { return fChannelIter     ;}
    Int_t         GetEventID()        { return fEventNumber     ;}
    TH1*          GetHisto(char* histname);
    Int_t         GetRCUPatch(Int_t runid, Int_t eqid);
    
    Int_t         GetPadAtX(Float_t xval, Int_t row, Int_t padmax);
    Int_t         GetPadAtX(Float_t xval, Int_t row);
    void          GetXY( double& xval , double& yval , Int_t rowmax, Int_t row , Int_t pad);
    
    Int_t         IsLastEvent()       { return fLastEv          ;}
    
    Int_t         ProcessEvent(); 
    
    void          SetEventID(Int_t val)     { fEventNumber =val;}
    void          SetMirror(Int_t val)      { fMirror=val;}
    void          SetVerbose(Int_t val)     { fVerb = val;}
    void          SetMappingHandler(AliTPCMonitorMappingHandler* val ) { fMapHand  = val;}
    void          ShowSel(Int_t* comp_val);
    void          SetEqIds();
    
    void          ResizeCanv();
    void          ResetHistos();
    void          ResetArrays();
    Int_t         ReadData(    Int_t secid);
    
    Int_t         ReadDataDATEFile(Int_t secid); 
    Int_t         ReadDataDATEStream(Int_t secid); 
    Int_t         ReadDataDATESubEventLoop(AliTPCMonitorDateFormat* DateForm, Int_t secid);
    Int_t         ReadDataROOT(Int_t secid ); 
    
    void          WriteHistos() ;
    void          Write10bitChannel();
    

 private:
     
    ClassDef(AliTPCMonitor,1); 
}; 

#endif
Commit	Line	Data
48265b32	1
	2	#ifndef ALITPCMONITOR_H
	3	#define ALITPCMONITOR_H
	4
	5	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	6	* See cxx source for full Copyright notice */
	7
	8	/* $Id$ */
	9
	10
	11	////////////////////////////////////////////////////////////////////////
	12	//
	13	// AliTPCMonitor class
	14	//
	15	// Main class for TPC Monitor
	16	// Monitor can handle rootified data, files and online streams in DATE format.
	17	// The monitor GUI is started by the macro TPCMonitor.C
	18	//
	19	// Author: Stefan Kniege, IKF, Frankfurt
	20	//
	21	//
	22	/////////////////////////////////////////////////////////////////////////
	23
	24
	25	#include <stdio.h>
	26	#include <fstream>
	27	#include <stdlib.h>
	28	#include <iostream>
	29	#include <istream>
	30	#include <ostream>
	31	#include "TStyle.h"
	32	#include "TSystem.h"
	33	#include "TH2F.h"
	34	#include "TLegend.h"
	35	#include "TF1.h"
	36	#include "TMath.h"
	37	#include "TFormula.h"
	38	#include <string>
	39	#include "TROOT.h"
	40	#include "TCanvas.h"
	41	#include "TApplication.h"
	42	#include "TGaxis.h"
	43	#include "TPaveText.h"
	44	#include "TGButtonGroup.h"
	45	#include "TGButton.h"
	46	#include "TGTextBuffer.h"
	47	#include "TGTextEntry.h"
	48	#include "TGLabel.h"
	49	#include "TH3S.h"
	50	#include "AliTPCMonitorMappingHandler.h"
	51	#include "AliTPCMonitorDateFile.h"
	52	#include "AliTPCMonitorDateFormat.h"
	53	#include "AliTPCMonitorAltro.h"
	54	#include "AliTPCMonitorFFT.h"
	55	#include "AliTPCMonitorConfig.h"
	56	#include "AliSignalProcesor.h"
	57	#include "AliRawReaderRoot.h"
	58	#include "AliRawReader.h"
	59	#include "TGMsgBox.h"
	60	#include "TNamed.h"
	61	#include "TObject.h"
	62	#include "TDirectory.h"
	63	#include "AliLog.h"
	64	#include "RQ_OBJECT.h"
65
1954d2d0	66	class AliTPCMonitorDateMonitor;
48265b32	67
	68	using namespace std;
	69
	70	class AliTPCMonitor : public AliTPCMonitorConfig {
	71
	72	public:
	73
	74	AliTPCMonitor(char* name, char* title);
	75	virtual ~AliTPCMonitor();
	76
	77	// stats for size of arrays and histograms /////////////////////////////////////////////////
	78	Int_t** fPad; // array to store channel adc in time
	79	Float_t* fPadMapHw; // array to store mapping of hardware address and channel number
	80	Int_t** fPadMapRCU; // store multiple information for hardware address for debugging purpose (read out errors occur)
	81
	82
	83	// histograms to be used ////////////////////////////////////////////////////////////////
	84	TH2F* fHistIROC; // histo for max adc IROC
	85	TH2F* fHistOROC; // histo for max adc OROC
	86	TH2S* fHistIROCIndex; // histo for channel number in each bin IROC
	87	TH2S* fHistOROCIndex; // histo for channel number in each bin OROC
	88	TH2F* fHistIROCTime; // histo for peaking time in each bin IROC
	89	TH2F* fHistOROCTime; // histo for peaking time in each bin OROC
	90	TH2F* fHistIROCClone; // clone histo for max adc IROC (backup when selecting component)
	91	TH2F* fHistOROCClone; // clone histo for max adc OROC (backup when selecting component)
	92	TH2F* fHistIROCRMS; // histo for RMS IROC
	93	TH2F* fHistOROCRMS; // histo for RMS OROC
	94	TH2F* fHistIROCBASE; // histo for baseline IROC
	95	TH2F* fHistOROCBASE; // histo for baseline OROC
	96	TH2F* fHistIROCSUM; // histo for adc sum IROC
	97	TH2F* fHistOROCSUM; // histo for adc sum OROC
	98
	99	TH2F* fHistChannelTime; // histo for adc(channel,time)
	100	TH1F* fHistAddrMapIndex; // histo for channel(hardware address)
	101	TH1F* fHistAddrMaxAdc; // histo for max-adc(hardware address)
	102	TH1F* fHistAddrBaseMean; // histo for baseline(hardware address)
	103	TH1F* fHistAddrMaxAdcX; // histo for max-adc-xposition(hardware address)
	104	TH1F* fHistAddrAdcSum; // histo for adc-sum(hardware address)
	105	TH1F* fHistAddrBaseRms; // histo for baselinr-rms(hardware address)
	106
	107	TH1F* fHistDistrSumIROC; // distribution of adc sum for all channels IROC
	108	TH1F* fHistDistrMaxIROC; // distribution of adc max for all channels OROC
	109	TH1F* fHistDistrSumOROC; // distribution of adc sum for all channels OROC
	110	TH1F* fHistDistrMaxOROC; // distribution of adc max for all channels OROC
	111
	112	TH2F* fHistDistrBase2dIROC; // distribution of baseline vs rms for all channels IROC
	113	TH2F* fHistDistrBase2dOROC; // distribution of baseline vs rms for all channels OROC
	114	TH1D* fHistDistrBaseRmsIROC; // projection of fHistDistrBase2dIROC on Rms
	115	TH1D* fHistDistrBaseMeanIROC; // projection of fHistDistrBase2dIROC on Mean
	116	TH1D* fHistDistrBaseRmsOROC; // projection of fHistDistrBase2dOROC on Rms
	117	TH1D* fHistDistrBaseMeanOROC; // projection of fHistDistrBase2dOROC on Mean
	118
	119	TH2S* fHistGlobalMaxA; // global histogramm for max adc of all sectors Side A
	120	TH2S* fHistGlobalMaxC; // global histogramm for max adc of all sectors Side C
	121
	122	TObjArray* fHistList; // array to store all histogram
	123
	124
	125	// row and pad settings
	126	Int_t kNRowsIroc; // number of rows in IROC
	127	Int_t kNRowsOroc; // number of rows in OROC
	128
	129	Int_t kNPadsIroc; // number of pads in IROC
	130	Int_t kNPadsOroc; // number of pads in OROC
131
132	Int_t kNPadMinIroc; // min for pad (y-axis) representation in 2D histogram IROC
133	Int_t kNPadMinOroc; // min for pad (y-axis) representation in 2D histogram OROC
134	Int_t kNPadMaxIroc; // max for pad (y-axis) representation in 2D histogram IROC
135	Int_t kNPadMaxOroc; // max for pad (y-axis) representation in 2D histogram IROC
136
137	Int_t fVerb; // verbose flag
138
139	Int_t fLastEv; // flag for last event
140
141	Int_t fEventNumber; // current event number (ID)
142	Int_t fEventNumberOld; // previous event number
143
144	Int_t fDisableFit; // flag to disable fit of maximum peak
145
146	Int_t fExecGlob; // flag to add Executable to global histo
147	Int_t fExecPlaneMax; // flag to add executable for plane view ( max iroc/oroc)
148	Int_t fExecPadIrocRms; // flag to add executable for rms plane view IROC
149	Int_t fExecPadOrocRms; // flag to add executable for rms plane view OROC
150
151	Int_t fRunId; // current run id
152	Int_t fEqId; // currend equipment id
153
154	Int_t fPadUsedRoc; // last ROC canvas the mouse pointed at
155	Int_t fPadUsedHwAddr; // hwaddress for last pad the mouse pointed at
156
157	Int_t fGdcId; // current GDC id
158	Int_t fLdcId; // current LDC id
159	Int_t fLdcIdOld; // previous LDC id
160
161	Int_t** fMapEqidsSec; // mapping rcu-patch(equipmentid)
162	Int_t* fMapEqidsRcu; // mapping equipmentid(sector,rcu-patch)
163
164	Int_t fMirror; // mirror x position on C-side
165	Int_t fChannelIter; // counter for channels read
166
167
168	AliTPCMonitorMappingHandler* fMapHand; // mapping handler
169
170	AliRawReaderRoot* fReaderROOT; // reader for ROOT format
171	AliTPCMonitorDateFile* fReaderDATE; // reader for DATE files
172
48265b32	173	AliTPCMonitorDateMonitor* fReaderDATEMon; // reader for DATE monitoring
48265b32	174
	175
	176	Int_t CheckEqId(Int_t secid, Int_t eqid);
	177	TCanvas* CreateCanvas(char* name);
	178	void CreateHistos();
	179
	180	void DeleteHistos();
	181	void DisableFit(Int_t val) { fDisableFit =val; }
	182	void DrawHists(Int_t histos);
	183	void DrawRMSMap();
	184	void DumpHeader(AliRawReaderRoot* reader );
	185	void DumpHeader(AliTPCMonitorDateFormat* DateForm);
	186
	187	void ExecPad() ;
	188	void ExecRow() ;
	189	Int_t ExecProcess();
	190	void ExecTransform();
	191
	192	void FillGlobal(Int_t sector);
	193	void FillHistsDecode( AliTPCMonitorAltro* altro , Int_t rcu_patch, Int_t id=0);
	194	void FillHistsPadPlane();
	195
	196	static double Gamma4(double* x, double* par);
	197	Int_t GetChannelsProc() { return fChannelIter ;}
	198	Int_t GetEventID() { return fEventNumber ;}
	199	TH1* GetHisto(char* histname);
	200	Int_t GetRCUPatch(Int_t runid, Int_t eqid);
	201
	202	Int_t GetPadAtX(Float_t xval, Int_t row, Int_t padmax);
	203	Int_t GetPadAtX(Float_t xval, Int_t row);
	204	void GetXY( double& xval , double& yval , Int_t rowmax, Int_t row , Int_t pad);
	205
	206	Int_t IsLastEvent() { return fLastEv ;}
	207
	208	Int_t ProcessEvent();
	209
	210	void SetEventID(Int_t val) { fEventNumber =val;}
	211	void SetMirror(Int_t val) { fMirror=val;}
	212	void SetVerbose(Int_t val) { fVerb = val;}
	213	void SetMappingHandler(AliTPCMonitorMappingHandler* val ) { fMapHand = val;}
	214	void ShowSel(Int_t* comp_val);
	215	void SetEqIds();
	216
	217	void ResizeCanv();
	218	void ResetHistos();
	219	void ResetArrays();
	220	Int_t ReadData( Int_t secid);
	221
	222	Int_t ReadDataDATEFile(Int_t secid);
48265b32	223	Int_t ReadDataDATEStream(Int_t secid);
48265b32	224	Int_t ReadDataDATESubEventLoop(AliTPCMonitorDateFormat* DateForm, Int_t secid);
	225	Int_t ReadDataROOT(Int_t secid );
	226
	227	void WriteHistos() ;
	228	void Write10bitChannel();
	229
	230
	231
	232
	233
	234
	235	private:
	236
	237	ClassDef(AliTPCMonitor,1);
	238	};
	239
	240	#endif