New version of calibration viewer + minor changes in the calib objects (Lars, Stefan...
authormarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 6 Jun 2007 12:51:14 +0000 (12:51 +0000)
committermarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 6 Jun 2007 12:51:14 +0000 (12:51 +0000)
TPC/AliTPCCalPad.cxx
TPC/AliTPCCalPad.h
TPC/AliTPCCalROC.cxx
TPC/AliTPCCalROC.h
TPC/AliTPCCalibViewer.cxx
TPC/AliTPCCalibViewer.h
TPC/AliTPCCalibViewerGUI.cxx
TPC/AliTPCCalibViewerGUI.h

index 245a31a..10f33d9 100644 (file)
@@ -17,7 +17,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
-//  TPC calibration class for parameters which saved per pad                 //
+//  TPC calibration class for parameters which are saved per pad             //
+//  Each AliTPCCalPad consists of 72 AliTPCCalROC-objects                    //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -131,11 +132,25 @@ void AliTPCCalPad::Copy(TObject &c) const
   TObject::Copy(c);
 }
 
+
+void AliTPCCalPad::SetCalROC(AliTPCCalROC* roc, Int_t sector){
+   //
+   // Set AliTPCCalROC copies values from 'roc'
+   // if sector == -1 the sector specified in 'roc' is used
+   // else sector specified in 'roc' is ignored and specified sector is filled
+   //
+   if (sector == -1) sector = roc->GetSector();
+   for (UInt_t ichannel = 0; ichannel < roc->GetNchannels(); ichannel++) 
+      fROC[sector]->SetValue(ichannel, roc->GetValue(ichannel));
+}
+
+
+
 //_____________________________________________________________________________
 void AliTPCCalPad::Add(Float_t c1)
 {
     //
-    // add constant for all channels of all ROCs
+    // add constant c1 to all channels of all ROCs
     //
 
     for (Int_t isec = 0; isec < kNsec; isec++) {
@@ -148,9 +163,9 @@ void AliTPCCalPad::Add(Float_t c1)
 //_____________________________________________________________________________
 void AliTPCCalPad::Multiply(Float_t c1)
 {
-    //
-    // multiply constant for all channels of all ROCs
-    //
+  //
+  // multiply each channel of all ROCs with c1
+  //    
     for (Int_t isec = 0; isec < kNsec; isec++) {
        if (fROC[isec]){
            fROC[isec]->Multiply(c1);
@@ -161,9 +176,10 @@ void AliTPCCalPad::Multiply(Float_t c1)
 //_____________________________________________________________________________
 void AliTPCCalPad::Add(const AliTPCCalPad * pad, Double_t c1)
 {
-    //
-    // add calpad channel by channel multiplied by c1 - all ROCs
-    //
+  //
+  // multiply AliTPCCalPad 'pad' by c1 and add each channel to the coresponing channel in all ROCs
+  //  - pad by pad -
+  //
     for (Int_t isec = 0; isec < kNsec; isec++) {
        if (fROC[isec]){
            fROC[isec]->Add(pad->GetCalROC(isec),c1);
@@ -174,10 +190,11 @@ void AliTPCCalPad::Add(const AliTPCCalPad * pad, Double_t c1)
 //_____________________________________________________________________________
 void AliTPCCalPad::Multiply(const AliTPCCalPad * pad)
 {
-    //
-    // multiply calpad channel by channel - all ROCs
-    //
-    for (Int_t isec = 0; isec < kNsec; isec++) {
+  //
+  // multiply each channel of all ROCs with the coresponding channel of 'pad'
+  //     - pad by pad -
+  //
+   for (Int_t isec = 0; isec < kNsec; isec++) {
        if (fROC[isec]){
            fROC[isec]->Multiply(pad->GetCalROC(isec));
        }
@@ -187,9 +204,10 @@ void AliTPCCalPad::Multiply(const AliTPCCalPad * pad)
 //_____________________________________________________________________________
 void AliTPCCalPad::Divide(const AliTPCCalPad * pad)
 {
-    //
-    // divide calpad channel by channel - all ROCs
-    //
+  //
+  // divide each channel of all ROCs by the coresponding channel of 'pad'
+  //     - pad by pad -
+  //    
     for (Int_t isec = 0; isec < kNsec; isec++) {
        if (fROC[isec]){
            fROC[isec]->Divide(pad->GetCalROC(isec));
@@ -203,6 +221,7 @@ TGraph  *  AliTPCCalPad::MakeGraph(Int_t type, Float_t ratio){
   //   type=1 - mean
   //        2 - median
   //        3 - LTM
+  //
   Int_t npoints = 0;
   for (Int_t i=0;i<72;i++) if (fROC[i]) npoints++;
   TGraph * graph = new TGraph(npoints);
@@ -236,7 +255,7 @@ TGraph  *  AliTPCCalPad::MakeGraph(Int_t type, Float_t ratio){
 Double_t AliTPCCalPad::GetMeanRMS(Double_t &rms)
 {
     //
-    // Calculate mean an RMS of all rocs
+    // Calculates mean and RMS of all ROCs
     //
     Double_t sum = 0, sum2 = 0, n=0, val=0;
     for (Int_t isec = 0; isec < kNsec; isec++) {
@@ -351,6 +370,7 @@ TH1F * AliTPCCalPad::MakeHisto1D(Float_t min, Float_t max,Int_t type){
   // make 1D histo
   // type -1 = user defined range
   //       0 = nsigma cut nsigma=min
+  //
   if (type>=0){
     if (type==0){
       // nsigma range
@@ -400,6 +420,7 @@ TH2F *AliTPCCalPad::MakeHisto2D(Int_t side){
   // Make 2D graph
   // side  -  specify the side A = 0 C = 1
   // type  -  used types of determination of boundaries in z
+  //
   Float_t kEpsilon = 0.000000000001;
   TH2F * his = new TH2F(GetName(), GetName(), 250,-250,250,250,-250,250);
   AliTPCROC * roc  = AliTPCROC::Instance(); 
@@ -426,11 +447,204 @@ TH2F *AliTPCCalPad::MakeHisto2D(Int_t side){
 }
 
 
+AliTPCCalPad* AliTPCCalPad::LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* PadOutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction){
+   //
+   // Loops over all AliTPCCalROCs and performs a localFit in each ROC
+   // AliTPCCalPad with fit-data is returned
+   // rowRadius and padRadius specifies a window around a given pad in one sector. 
+   // The data of this window are fitted with a parabolic function. 
+   // This function is evaluated at the pad's position.
+   // At the edges the window is shifted, so that the specified pad is not anymore in the center of the window. 
+   // rowRadius  -  radius - rows to be used for smoothing
+   // padradius  -  radius - pads to be used for smoothing
+   // ROCoutlier -  map of outliers - pads not to be used for local smoothing
+   // robust     -  robust method of fitting  - (much slower)
+   // chi2Threshold: Threshold for chi2 when EvalRobust is called
+   // robustFraction: Fraction of data that will be used in EvalRobust
+   //
+   //
+   AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
+   for (Int_t isec = 0; isec < 72; isec++){
+      if (PadOutliers)
+         SetCalROC(GetCalROC(isec)->LocalFit(rowRadius, padRadius, PadOutliers->GetCalROC(isec), robust, chi2Threshold, robustFraction));
+      else 
+         SetCalROC(GetCalROC(isec)->LocalFit(rowRadius, padRadius, 0, robust, chi2Threshold, robustFraction));
+   }
+   return pad;
+}
+
+
+AliTPCCalPad* AliTPCCalPad::GlobalFit(const char* padName, AliTPCCalPad* PadOutliers, Bool_t robust, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction){
+   //
+   // Loops over all AliTPCCalROCs and performs a globalFit in each ROC
+   // AliTPCCalPad with fit-data is returned
+   // chi2Threshold: Threshold for chi2 when EvalRobust is called
+   // robustFraction: Fraction of data that will be used in EvalRobust
+   // chi2Threshold: Threshold for chi2 when EvalRobust is called
+   // robustFraction: Fraction of data that will be used in EvalRobust
+   //
+   AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
+   TVectorD fitParam(0);
+   TMatrixD covMatrix(0,0);
+   Float_t chi2 = 0;
+   for (Int_t isec = 0; isec < 72; isec++){
+      if (PadOutliers)
+         GetCalROC(isec)->GlobalFit(PadOutliers->GetCalROC(isec), robust, fitParam, covMatrix, chi2, fitType, chi2Threshold, robustFraction);
+      else 
+         GetCalROC(isec)->GlobalFit(0, robust, fitParam, covMatrix, chi2, fitType, chi2Threshold, robustFraction);
+      pad->SetCalROC(AliTPCCalROC::CreateGlobalFitCalROC(fitParam, isec));
+   }
+   return pad;
+}
+
+
+void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, TVectorD &fitParamSideA, TVectorD &fitParamSideC,TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t & chi2SideA, Float_t & chi2SideC, Int_t fitType, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction){
+  //
+  // Makes a  GlobalFit over each side and return fit-parameters, covariance and chi2 for each side
+  // fitType == 0: fit plane function
+  // fitType == 1: fit parabolic function
+  // PadOutliers - pads with value !=0 are not used in fitting procedure
+  // chi2Threshold: Threshold for chi2 when EvalRobust is called
+  // robustFraction: Fraction of data that will be used in EvalRobust
+  //
+  TLinearFitter* fitterGA = 0;
+  TLinearFitter* fitterGC = 0;
+  
+  if (fitType  == 1) {
+    fitterGA = new TLinearFitter (6,"x0++x1++x2++x3++x4++x5");
+    fitterGC = new TLinearFitter (6,"x0++x1++x2++x3++x4++x5");
+  }
+  else {
+    fitterGA = new TLinearFitter(3,"x0++x1++x2");
+    fitterGC = new TLinearFitter(3,"x0++x1++x2");
+  }
+  fitterGA->StoreData(kTRUE);   
+  fitterGC->StoreData(kTRUE);   
+  fitterGA->ClearPoints();
+  fitterGC->ClearPoints();
+  Double_t xx[6];  
+  Int_t    npointsA=0;
+  Int_t    npointsC=0;
+  
+  Float_t localXY[3] = {0}; // pad's position, needed to get the pad's position
+  Float_t lx, ly;  // pads position
+  
+  AliTPCROC* tpcROCinstance = AliTPCROC::Instance();  // to calculate the pad's position
+  
+  // loop over all sectors and pads and read data into fitterGA and fitterGC 
+  if (fitType == 1) {  
+  // parabolic fit
+    fitParamSideA.ResizeTo(6);
+    fitParamSideC.ResizeTo(6);
+    covMatrixSideA.ResizeTo(6,6);
+    covMatrixSideC.ResizeTo(6,6);
+    for (UInt_t isec = 0; isec<72; isec++){
+      for (UInt_t irow = 0; irow < GetCalROC(isec)->GetNrows(); irow++) {
+         for (UInt_t ipad = 0; ipad < GetCalROC(isec)->GetNPads(irow); ipad++) {
+            // fill fitterG
+            tpcROCinstance->GetPositionLocal(isec, irow, ipad, localXY);   // calculate position localXY by sector, pad and row number
+            lx = localXY[0];
+            ly = localXY[1];
+            xx[0] = 1;
+            xx[1] = lx;
+            xx[2] = ly;
+            xx[3] = lx*lx;
+            xx[4] = ly*ly;
+            xx[5] = lx*ly;
+            if (!PadOutliers || PadOutliers->GetCalROC(isec)->GetValue(irow, ipad) != 1) {
+            // if given pad is no outlier, add it to TLinearFitter, decide to which of both
+//                sector  0 - 17: IROC, A
+//                sector 18 - 35: IROC, C
+//                sector 36 - 53: OROC, A
+//                sector 54 - 71: CROC, C
+               if (isec <= 17 || (isec >= 36 && isec <= 53)) { // Side A
+                  npointsA++;
+                  fitterGA->AddPoint(xx, GetCalROC(isec)->GetValue(irow, ipad), 1);  
+               }
+               else { // side C
+                  npointsC++;
+                  fitterGC->AddPoint(xx, GetCalROC(isec)->GetValue(irow, ipad), 1);  
+               }
+            }
+         }
+      }
+    }
+  }
+  else {   
+  // linear fit
+    fitParamSideA.ResizeTo(3);
+    fitParamSideC.ResizeTo(3);
+    covMatrixSideA.ResizeTo(3,3);
+    covMatrixSideC.ResizeTo(3,3);
+    
+    for (UInt_t isec = 0; isec<72; isec++){
+      for (UInt_t irow = 0; irow < GetCalROC(isec)->GetNrows(); irow++) {
+         for (UInt_t ipad = 0; ipad < GetCalROC(isec)->GetNPads(irow); ipad++) {
+            // fill fitterG
+            tpcROCinstance->GetPositionLocal(isec, irow, ipad, localXY);   // calculate position localXY by sector, pad and row number
+            lx = localXY[0];
+            ly = localXY[1];
+            xx[0] = 1;
+            xx[1] = lx;
+            xx[2] = ly;
+            if (!PadOutliers || PadOutliers->GetCalROC(isec)->GetValue(irow, ipad) != 1) {
+            // if given pad is no outlier, add it to TLinearFitter, decide to which of both
+//                sector  0 - 17: IROC, A
+//                sector 18 - 35: IROC, C
+//                sector 36 - 53: OROC, A
+//                sector 54 - 71: CROC, C
+               if (isec <= 17 || (isec >= 36 && isec <= 53)) { 
+               // Side A
+                  npointsA++;
+                  fitterGA->AddPoint(xx, GetCalROC(isec)->GetValue(irow, ipad), 1);  
+               }
+               else { 
+               // side C
+                  npointsC++;
+                  fitterGC->AddPoint(xx, GetCalROC(isec)->GetValue(irow, ipad), 1);  
+               }
+            }
+         }
+      }
+    }
+  }    
+  
+  fitterGA->Eval();
+  fitterGC->Eval();
+  fitterGA->GetParameters(fitParamSideA);
+  fitterGC->GetParameters(fitParamSideC);
+  fitterGA->GetCovarianceMatrix(covMatrixSideA);
+  fitterGC->GetCovarianceMatrix(covMatrixSideC);
+  if (fitType == 1){
+    chi2SideA = fitterGA->GetChisquare()/(npointsA-6.);
+    chi2SideC = fitterGC->GetChisquare()/(npointsC-6.);
+  }
+  else {
+   chi2SideA = fitterGA->GetChisquare()/(npointsA-3.);
+   chi2SideC = fitterGC->GetChisquare()/(npointsC-3.);
+  }
+  if (robust && chi2SideA > chi2Threshold) {
+    //    std::cout << "robust fitter called... " << std::endl;
+    fitterGA->EvalRobust(robustFraction);
+    fitterGA->GetParameters(fitParamSideA);
+  }
+  if (robust && chi2SideC > chi2Threshold) {
+    //    std::cout << "robust fitter called... " << std::endl;
+    fitterGC->EvalRobust(robustFraction);
+    fitterGC->GetParameters(fitParamSideC);
+  }
+  delete fitterGA;
+  delete fitterGC;
+}
 
 
 void AliTPCCalPad::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
   //
-  // Write tree with all available information
+  // Write a tree with all available information
+  // im mapFileName is speciefied, the Map information are also written to the tree
+  // pads specified in outlierPad are not used for calculating statistics
+  //  - this function will be moved to AliTPCCalibViewer - 
+  //  - DO NOT USE THIS FUNCTION ANY MORE - 
   //
    AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
 
@@ -621,7 +835,6 @@ void AliTPCCalPad::MakeTree(const char * fileName, TObjArray * array, const char
       delete[] posArray;
       delete[] vectorArray;
    }
-   
    delete[] names;
    if (mapFileName) {
       delete mapIROCs;
index 095d143..9b52ca8 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "TNamed.h"
+//#include <TMath.h>
+//#include <AliTPCROC.h>
+#include "TLinearFitter.h"
+//#include <iostream>
+
+
 
 class AliTPCCalROC;
 class AliTPCCalDet;
@@ -30,23 +36,30 @@ class AliTPCCalPad : public TNamed {
   virtual ~AliTPCCalPad();
   AliTPCCalPad &operator=(const AliTPCCalPad &c);
   virtual void     Copy(TObject &c) const;
-  AliTPCCalROC *GetCalROC(Int_t sector) const { return fROC[sector]; };  
+  AliTPCCalROC *GetCalROC(Int_t sector) const {return fROC[sector]; };  
+  void SetCalROC(AliTPCCalROC* roc, Int_t sector = -1);
   //
   // algebra
-  void Add(Float_t c1);
-  void Multiply(Float_t c1);
-  void Add(const AliTPCCalPad * roc, Double_t c1 = 1);
-  void Multiply(const AliTPCCalPad * pad);
-  void Divide(const AliTPCCalPad * pad);
+  void Add(Float_t c1);   // add constant c1 to all channels of all ROCs
+  void Multiply(Float_t c1);   // multiply each channel of all ROCs with c1
+  void Add(const AliTPCCalPad * roc, Double_t c1 = 1);   // multiply AliTPCCalPad 'pad' by c1 and add each channel to the coresponing channel in all ROCs
+  void Multiply(const AliTPCCalPad * pad);  // multiply each channel of all ROCs with the coresponding channel of 'pad'
+  void Divide(const AliTPCCalPad * pad);    // divide each channel of all ROCs by the coresponding channel of 'pad'
   //
-  Double_t GetMeanRMS(Double_t &rms);
-  Double_t GetMean(AliTPCCalPad* outlierPad = 0);
-  Double_t GetRMS(AliTPCCalPad* outlierPad = 0) ;
-  Double_t GetMedian(AliTPCCalPad* outlierPad = 0) ;
-  Double_t GetLTM(Double_t *sigma=0, Double_t fraction=0.9, AliTPCCalPad* outlierPad = 0);
+  Double_t GetMeanRMS(Double_t &rms);   // Calculates mean and RMS of all ROCs
+  Double_t GetMean(AliTPCCalPad* outlierPad = 0);   // return mean of the mean of all ROCs
+  Double_t GetRMS(AliTPCCalPad* outlierPad = 0) ;   // return mean of the RMS of all ROCs
+  Double_t GetMedian(AliTPCCalPad* outlierPad = 0) ;   // return mean of the median of all ROCs
+  Double_t GetLTM(Double_t *sigma=0, Double_t fraction=0.9, AliTPCCalPad* outlierPad = 0);   // return mean of the LTM and sigma of all ROCs
   TGraph  *MakeGraph(Int_t type=0, Float_t ratio=0.7);
   TH2F    *MakeHisto2D(Int_t side=0);
   TH1F    *MakeHisto1D(Float_t min=4, Float_t max=-4, Int_t type=0);  
+
+  AliTPCCalPad* LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* Padoutliers = 0, Bool_t robust = kFALSE, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7);
+  AliTPCCalPad* GlobalFit(const char* padName, AliTPCCalPad* Padoutliers = 0, Bool_t robust = kFALSE, Int_t fitType = 1, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7);
+  void GlobalSidesFit(const AliTPCCalPad* PadOutliers, TVectorD &fitParamSideA, TVectorD &fitParamSideC, TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t &chi2SideA, Float_t &chi2SideC, Int_t fitType = 1, Bool_t robust = kFALSE, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7);
+
+    
   static void MakeTree(const char * fileName, TObjArray * array, const char * mapFileName = 0, AliTPCCalPad* outlierPad = 0, Float_t ltmFraction = 0.9);
  protected:
   AliTPCCalROC *fROC[kNsec];                    //  Array of ROC objects which contain the values per pad
index f8e23dc..d296bc0 100644 (file)
@@ -16,8 +16,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
-//  Calibration base class for a single ROC                                  //
-//  Contains one float value per pad                                         //
+//     Calibration base class for a single ROC                               //
+//     Contains one float value per pad                                      //
 //     mapping of the pads taken form AliTPCROC                              //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
@@ -123,7 +123,9 @@ AliTPCCalROC::~AliTPCCalROC()
 
 void AliTPCCalROC::Streamer(TBuffer &R__b)
 {
+   //
    // Stream an object of class AliTPCCalROC.
+   //
    if (R__b.IsReading()) {
       AliTPCCalROC::Class()->ReadBuffer(R__b, this);
       fIndexes =  AliTPCROC::Instance()->GetRowIndexes(fSector);
@@ -132,29 +134,29 @@ void AliTPCCalROC::Streamer(TBuffer &R__b)
    }
 }
 
-//  //
-//   // algebra
-//   void Add(Float_t c1);
-//   void Multiply(Float_t c1);
-//   void Add(const AliTPCCalROC * roc, Double_t c1 = 1);
-//   void Divide(const AliTPCCalROC * roc);   
+
+// algebra fuctions:
 
 void AliTPCCalROC::Add(Float_t c1){
   //
-  // add constant
+  // add c1 to each channel of the ROC  
   //
   for (UInt_t  idata = 0; idata< fNChannels; idata++) fData[idata]+=c1;
 }
+
+
 void AliTPCCalROC::Multiply(Float_t c1){
   //
-  // add constant
+  // multiply each channel of the ROC with c1
   //
   for (UInt_t  idata = 0; idata< fNChannels; idata++) fData[idata]*=c1;
 }
 
+
 void AliTPCCalROC::Add(const AliTPCCalROC * roc, Double_t c1){
   //
-  // add values 
+  // multiply AliTPCCalROC roc by c1 and add each channel to the coresponing channel in the ROC
+  //  - pad by pad 
   //
   for (UInt_t  idata = 0; idata< fNChannels; idata++){
     fData[idata]+=roc->fData[idata]*c1;
@@ -164,7 +166,8 @@ void AliTPCCalROC::Add(const AliTPCCalROC * roc, Double_t c1){
 
 void AliTPCCalROC::Multiply(const AliTPCCalROC*  roc) {
   //
-  // multiply values - per by pad
+  // multiply each channel of the ROC with the coresponding channel of 'roc'
+  //     - pad by pad -
   //
   for (UInt_t  idata = 0; idata< fNChannels; idata++){
     fData[idata]*=roc->fData[idata];
@@ -174,7 +177,8 @@ void AliTPCCalROC::Multiply(const AliTPCCalROC*  roc) {
 
 void AliTPCCalROC::Divide(const AliTPCCalROC*  roc) {
   //
-  // divide values 
+  // divide each channel of the ROC by the coresponding channel of 'roc'
+  //     - pad by pad -
   //
   Float_t kEpsilon=0.00000000000000001;
   for (UInt_t  idata = 0; idata< fNChannels; idata++){
@@ -184,6 +188,10 @@ void AliTPCCalROC::Divide(const AliTPCCalROC*  roc) {
 }
 
 Double_t AliTPCCalROC::GetMean(AliTPCCalROC* outlierROC) {
+   //
+   //  returns the mean value of the ROC
+   //  pads with value != 0 in outlierROC are not used for the calculation
+   //
    if (!outlierROC) return TMath::Mean(fNChannels, fData);
    Double_t *ddata = new Double_t[fNChannels];
    Int_t NPoints = 0;
@@ -199,6 +207,10 @@ Double_t AliTPCCalROC::GetMean(AliTPCCalROC* outlierROC) {
 }
 
 Double_t AliTPCCalROC::GetMedian(AliTPCCalROC* outlierROC) {
+   //
+   //  returns the median value of the ROC
+   //  pads with value != 0 in outlierROC are not used for the calculation
+   //
    if (!outlierROC) return TMath::Median(fNChannels, fData);
    Double_t *ddata = new Double_t[fNChannels];
    Int_t NPoints = 0;
@@ -214,6 +226,10 @@ Double_t AliTPCCalROC::GetMedian(AliTPCCalROC* outlierROC) {
 }
 
 Double_t AliTPCCalROC::GetRMS(AliTPCCalROC* outlierROC) {
+   //
+   //  returns the RMS value of the ROC
+   //  pads with value != 0 in outlierROC are not used for the calculation
+   //
    if (!outlierROC) return TMath::RMS(fNChannels, fData);
    Double_t *ddata = new Double_t[fNChannels];
    Int_t NPoints = 0;
@@ -230,7 +246,8 @@ Double_t AliTPCCalROC::GetRMS(AliTPCCalROC* outlierROC) {
 
 Double_t AliTPCCalROC::GetLTM(Double_t *sigma, Double_t fraction, AliTPCCalROC* outlierROC){
   //
-  //  Calculate LTM mean and sigma
+  //  returns the LTM and sigma
+  //  pads with value != 0 in outlierROC are not used for the calculation
   //
   Double_t *ddata = new Double_t[fNChannels];
   Double_t mean=0, lsigma=0;
@@ -254,6 +271,7 @@ TH1F * AliTPCCalROC::MakeHisto1D(Float_t min, Float_t max,Int_t type){
   // type -1 = user defined range
   //       0 = nsigma cut nsigma=min
   //       1 = delta cut around median delta=min
+  //
   if (type>=0){
     if (type==0){
       // nsigma range
@@ -301,6 +319,7 @@ TH2F * AliTPCCalROC::MakeHisto2D(Float_t min, Float_t max,Int_t type){
   // type -1 = user defined range
   //       0 = nsigma cut nsigma=min
   //       1 = delta cut around median delta=min
+  //
   if (type>=0){
     if (type==0){
       // nsigma range
@@ -352,6 +371,7 @@ TH2F * AliTPCCalROC::MakeHistoOutliers(Float_t delta, Float_t fraction, Int_t ty
   // fraction - fraction of values used to define sigma
   // delta - in mode 0 - nsigma cut
   //            mode 1 - delta cut
+  //
   Double_t sigma;
   Float_t mean  = GetLTM(&sigma,fraction);  
   if (type==0) delta*=sigma; 
@@ -531,35 +551,39 @@ void AliTPCCalROC::Test() {
 }
 
 
-AliTPCCalROC * AliTPCCalROC::LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCalROC* ROCoutliers, Bool_t robust) {
+AliTPCCalROC * AliTPCCalROC::LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCalROC* ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction) {
   //
   // MakeLocalFit - smoothing
+  // returns a AliTPCCalROC with smoothed data
+  // rowRadius and padRadius specifies a window around a given pad. 
+  // The data of this window are fitted with a parabolic function. 
+  // This function is evaluated at the pad's position.
+  // At the edges the window is shifted, so that the specified pad is not anymore in the center of the window. 
   // rowRadius  -  radius - rows to be used for smoothing
   // padradius  -  radius - pads to be used for smoothing
   // ROCoutlier -  map of outliers - pads not to be used for local smoothing
   // robust     -  robust method of fitting  - (much slower)
-  
+  // chi2Threshold: Threshold for chi2 when EvalRobust is called
+  // robustFraction: Fraction of data that will be used in EvalRobust
+  //
   AliTPCCalROC * ROCfitted = new AliTPCCalROC(fSector);
-  TLinearFitter fitterQ(6,"x0++x1++x2++x3++x4++x5");
+  TLinearFitter fitterQ(6,"hyp5");
+   // TLinearFitter fitterQ(6,"x0++x1++x2++x3++x4++x5");
   fitterQ.StoreData(kTRUE);
   for (UInt_t row=0; row < GetNrows(); row++) {
     //std::cout << "Entering row " << row << " of " << GetNrows() << " @ sector "<< fSector << " for local fitting... "<< std::endl;
     for (UInt_t pad=0; pad < GetNPads(row); pad++)
-      ROCfitted->SetValue(row, pad, GetNeighbourhoodValue(&fitterQ, row, pad, rowRadius, padRadius, ROCoutliers, robust));
+      ROCfitted->SetValue(row, pad, GetNeighbourhoodValue(&fitterQ, row, pad, rowRadius, padRadius, ROCoutliers, robust, chi2Threshold, robustFraction));
   }
   return ROCfitted;
 }
 
 
-Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC* ROCoutliers, Bool_t robust) {
+Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC* ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction) {
+  //
+  // AliTPCCalROC::GetNeighbourhoodValue - smoothing - PRIVATE
+  // in this function the fit for LocalFit is done
   //
-  //  AliTPCCalROC::GetNeighbourhoodValue - smoothing (PRIVATE)
-  // rowRadius  -  radius - rows to be used for smoothing
-  // padradius  -  radius - pads to be used for smoothing
-  // ROCoutlier -  map of outliers - pads not to be used for local smoothing
-  // robust     -  robust method of fitting  - (much slower)
-  
-
 
   fitterQ->ClearPoints();
   TVectorD fitParam(6);
@@ -587,14 +611,14 @@ Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row,
     tpcROCinstance->GetPositionLocal(fSector, r, p, localXY);   // calculate position localXY by pad and row number
     dlx = lPad[0] - localXY[0];
     dly = lPad[1] - localXY[1];
-    xx[0] = 1;
+    //xx[0] = 1;
     xx[1] = dlx;
     xx[2] = dly;
     xx[3] = dlx*dlx;
     xx[4] = dly*dly;
     xx[5] = dlx*dly;
     if (!ROCoutliers || ROCoutliers->GetValue(r,p) != 1) {
-      fitterQ->AddPoint(xx, GetValue(r, p), 1);
+      fitterQ->AddPoint(&xx[1], GetValue(r, p), 1);
       npoints++;
     }
   }
@@ -609,17 +633,16 @@ Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row,
   fitterQ->Eval();
   fitterQ->GetParameters(fitParam);
   Float_t chi2Q = 0;
-  chi2Q = fitterQ->GetChisquare()/(npoints-6.);
+  if (robust) chi2Q = fitterQ->GetChisquare()/(npoints-6.);
   //if (robust) chi2Q = fitterQ->GetChisquare()/(npoints-6.);
-  if (robust && chi2Q > 5) {
+  if (robust && chi2Q > chi2Threshold) {
     //std::cout << "robust fitter called... " << std::endl;
-    fitterQ->EvalRobust(0.7);
+    fitterQ->EvalRobust(robustFraction);
     fitterQ->GetParameters(fitParam);
   }
   Double_t value = fitParam[0];
   
   //if (value < 0) std::cerr << "negative fit-value " << value << " in sector "<< this->fSector << " @ row: " << row << " and pad: " << pad << ", with fitter Chi2 = " << chi2Q <<  std::endl;
-  
   return value;
 }
 
@@ -628,12 +651,11 @@ Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row,
 
 void AliTPCCalROC::GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius) {
   //
-  //
+  // AliTPCCalROC::GetNeighbourhood - PRIVATE
+  // in this function the window for LocalFit is determined
   //
   rowArray = new TArrayI((2*rRadius+1)*(2*pRadius+1));
   padArray = new TArrayI((2*rRadius+1)*(2*pRadius+1));
-  //Int_t* rowArrayTemp = rowArray->GetArray();
-  //Int_t* padArrayTemp = padArray->GetArray();
   
   Int_t rmin = row - rRadius;
   UInt_t rmax = row + rRadius;
@@ -680,14 +702,16 @@ void AliTPCCalROC::GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_
 
 
 
-void AliTPCCalROC::GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVectorD &fitParam, TMatrixD &covMatrix, Float_t & chi2, Int_t fitType){
+void AliTPCCalROC::GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVectorD &fitParam, TMatrixD &covMatrix, Float_t & chi2, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction){
+  //
+  // Makes a  GlobalFit for the given secotr and return fit-parameters, covariance and chi2
+  // The origin of the fit function is the center of the ROC!
+  // fitType == 0: fit plane function
+  // fitType == 1: fit parabolic function
+  // ROCoutliers - pads with value !=0 are not used in fitting procedure
+  // chi2Threshold: Threshold for chi2 when EvalRobust is called
+  // robustFraction: Fraction of data that will be used in EvalRobust
   //
-  // Makes global fit  
-  // do GlobalFit for given Secotr and return fit-parameters, covariance, and whatever
-  // fitType == 0: fit plane
-  // fitType == 1: fit parabolic
-  // ROCoutliers - pads signed=1 - not used in fitting procedure
-   
   TLinearFitter* fitterG = 0;
   Double_t xx[6];
   
@@ -754,23 +778,20 @@ void AliTPCCalROC::GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVe
   if (fitType == 1)
     chi2 = fitterG->GetChisquare()/(npoints-6.);
   else chi2 = fitterG->GetChisquare()/(npoints-3.);
-  if (robust && chi2 > 5) {
+  if (robust && chi2 > chi2Threshold) {
     //    std::cout << "robust fitter called... " << std::endl;
-    fitterG->EvalRobust(0.7);
+    fitterG->EvalRobust(robustFraction);
     fitterG->GetParameters(fitParam);
   }
   delete fitterG;
 }
 
 
-//
 AliTPCCalROC* AliTPCCalROC::CreateGlobalFitCalROC(TVectorD &fitParam, Int_t sector){
   //
-  //
   // Create ROC with global fit parameters
-  // fitType == 0: fit plane
-  // fitType == 1: fit parabolic
-  // loop over all channels and write fit values into ROCfitted
+  // The origin of the fit function is the center of the ROC!
+  // loop over all channels, write fit values into new ROC and return it
   //
   Float_t dlx, dly;
   Float_t centerPad[3] = {0};
index c633868..80ac490 100644 (file)
@@ -39,11 +39,11 @@ class AliTPCCalROC : public TObject {
   virtual void Draw(Option_t* option = "");
   //
   // algebra
-  void Add(Float_t c1);
-  void Multiply(Float_t c1);
-  void Add(const AliTPCCalROC * roc, Double_t c1 = 1);
-  void Multiply(const AliTPCCalROC * roc);   
-  void Divide(const AliTPCCalROC * roc);   
+  void Add(Float_t c1); // add c1 to each channel of the ROC
+  void Multiply(Float_t c1); // multiply each channel of the ROC with c1
+  void Add(const AliTPCCalROC * roc, Double_t c1 = 1);  // multiply AliTPCCalROC roc by c1 and add each channel to the coresponing channel in the ROC
+  void Multiply(const AliTPCCalROC * roc);   // multiply each channel of the ROC with the coresponding channel of 'roc'
+  void Divide(const AliTPCCalROC * roc);   // divide each channel of the ROC by the coresponding value of 'roc'
   // statistic
   //
   Double_t GetMean(AliTPCCalROC* outlierROC = 0);
@@ -54,16 +54,15 @@ class AliTPCCalROC : public TObject {
   TH2F * MakeHisto2D(Float_t min=4, Float_t max=-4, Int_t type=0);   
   TH2F * MakeHistoOutliers(Float_t delta=4, Float_t fraction=0.7, Int_t mode=0);
 
-  AliTPCCalROC * LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCalROC* ROCoutliers = 0, Bool_t robust = kFALSE);
-  //
-  void GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVectorD &fitParam, TMatrixD &covMatrix, Float_t & chi2, Int_t fitType = 1);
-  //
+  AliTPCCalROC * LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCalROC* ROCoutliers = 0, Bool_t robust = kFALSE, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7);
+  void GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVectorD &fitParam, TMatrixD &covMatrix, Float_t & chi2, Int_t fitType = 1, Double_t chi2Threshold = 5, Double_t robustFraction = 0.7);
+  
   static AliTPCCalROC* CreateGlobalFitCalROC(TVectorD &fitParam, Int_t sector);
   
   static void Test();
  protected:
   
-  Double_t GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC* ROCoutliers, Bool_t robust);
+  Double_t GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC* ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction);
   void GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius);
   
   UInt_t     fSector;          // sector number
index f71a4db..fd06aae 100644 (file)
@@ -50,7 +50,8 @@ AliTPCCalibViewer::AliTPCCalibViewer()
                   :TObject(),
                    fTree(0),
                    fFile(0),
-                   fListOfObjectsToBeDeleted(0)
+                   fListOfObjectsToBeDeleted(0),
+                   fTreeMustBeDeleted(0)
 {
   //
   // Default constructor
@@ -63,13 +64,15 @@ AliTPCCalibViewer::AliTPCCalibViewer(const AliTPCCalibViewer &c)
                   :TObject(c),
                    fTree(0),
                    fFile(0),
-                   fListOfObjectsToBeDeleted(0)
+                   fListOfObjectsToBeDeleted(0),
+                   fTreeMustBeDeleted(0)
 {
   //
   // dummy AliTPCCalibViewer copy constructor
   // not yet working!!!
   //
   fTree = c.fTree;
+  fTreeMustBeDeleted = c.fTreeMustBeDeleted;
   //fFile = new TFile(*(c.fFile));
   fListOfObjectsToBeDeleted = c.fListOfObjectsToBeDeleted;
 }
@@ -79,12 +82,14 @@ AliTPCCalibViewer::AliTPCCalibViewer(TTree* tree)
                   :TObject(),
                    fTree(0),
                    fFile(0),
-                   fListOfObjectsToBeDeleted(0)
+                   fListOfObjectsToBeDeleted(0),
+                   fTreeMustBeDeleted(0)
 {
   //
   // Constructor that initializes the calibration viewer
   //
   fTree = tree;
+  fTreeMustBeDeleted = kFALSE;
   fListOfObjectsToBeDeleted = new TObjArray();
 }
 
@@ -93,7 +98,8 @@ AliTPCCalibViewer::AliTPCCalibViewer(char* fileName, char* treeName)
                   :TObject(),
                    fTree(0),
                    fFile(0),
-                   fListOfObjectsToBeDeleted(0)
+                   fListOfObjectsToBeDeleted(0),
+                   fTreeMustBeDeleted(0)
 {
    //
    // Constructor to initialize the calibration viewer
@@ -101,6 +107,7 @@ AliTPCCalibViewer::AliTPCCalibViewer(char* fileName, char* treeName)
    //
    fFile = new TFile(fileName, "read");
    fTree = (TTree*) fFile->Get(treeName);
+   fTreeMustBeDeleted = kTRUE;
    fListOfObjectsToBeDeleted = new TObjArray();
 }
                    
@@ -112,6 +119,7 @@ AliTPCCalibViewer & AliTPCCalibViewer::operator =(const AliTPCCalibViewer & para
    // not yet working!!!
    //
    fTree = param.fTree;
+   fTreeMustBeDeleted = param.fTreeMustBeDeleted;
    //fFile = new TFile(*(param.fFile));
    fListOfObjectsToBeDeleted = param.fListOfObjectsToBeDeleted;
    return (*this);
@@ -122,12 +130,13 @@ AliTPCCalibViewer::~AliTPCCalibViewer()
 {
    //
    // AliTPCCalibViewer destructor
-   // all objects will be deleted, the file will be closed, the pictures will disapear
+   // all objects will be deleted, the file will be closed, the pictures will disappear
    //
-   /*if (fTree) {
-      delete fTree;
-      fTree = 0;
-   }*/
+   if (fTree && fTreeMustBeDeleted) {
+      fTree->SetCacheSize(0);
+      fTree->Delete();
+      //delete fTree;
+   }
    if (fFile) {
       fFile->Close();
       fFile = 0;
@@ -141,6 +150,24 @@ AliTPCCalibViewer::~AliTPCCalibViewer()
 }
 
 //_____________________________________________________________________________
+void AliTPCCalibViewer::Delete(Option_t* option) {
+   //
+   // Should be called from AliTPCCalibViewerGUI class only.
+   // If you use Delete() do not call the destructor.
+   // All objects (except those contained in fListOfObjectsToBeDeleted) will be deleted, the file will be closed.
+   //
+   
+   option = option;  // to avoid warnings on compiling   
+   if (fTree && fTreeMustBeDeleted) {
+      fTree->SetCacheSize(0);
+      fTree->Delete();
+   }
+   if (fFile)
+      delete fFile;
+   delete fListOfObjectsToBeDeleted;
+}
+
+//_____________________________________________________________________________
 Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
   //
   // easy drawing of data, use '~' for abbreviation of '.fElements'
@@ -536,6 +563,7 @@ AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, char* cuts,
    Int_t entries = 0;
    for (Int_t sec = 0; sec < 72; sec++) {
       entries = EasyDraw1D(drawStr.Data(), (Int_t)sec, cuts, "goff");
+      if (entries == -1) return 0;
       for (Int_t i = 0; i < entries; i++) 
          createdCalPad->GetCalROC(sec)->SetValue((UInt_t)(fTree->GetV2()[i]), (Float_t)(fTree->GetV1()[i]));
    }
@@ -552,6 +580,7 @@ AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t secto
    TString drawStr(desiredData);
    drawStr.Append(":channel~");
    Int_t entries = EasyDraw1D(drawStr.Data(), (Int_t)sector, cuts, "goff");
+   if (entries == -1) return 0;
    AliTPCCalROC * createdROC = new AliTPCCalROC(sector);
    for (Int_t i = 0; i < entries; i++) 
       createdROC->SetValue((UInt_t)(fTree->GetV2()[i]), fTree->GetV1()[i]);
@@ -611,6 +640,8 @@ TObjArray* AliTPCCalibViewer::GetListOfNormalizationVariables(Bool_t printList)
    arr->Add(new TObjString("LFitIntern_4_8.fElements"));
    arr->Add(new TObjString("GFitIntern_Lin.fElements"));
    arr->Add(new TObjString("GFitIntern_Par.fElements"));
+   arr->Add(new TObjString("FitLinLocal"));
+   arr->Add(new TObjString("FitLinGlobal"));
 
    if (printList) {
       TIterator* iter = arr->MakeIterator();
@@ -660,6 +691,75 @@ TObjArray* AliTPCCalibViewer::GetArrayOfCalPads(){
 }
 
 
+TString* AliTPCCalibViewer::Fit(const char* drawCommand, const char* formula, const char* cuts, Double_t & chi2, TVectorD &fitParam, TMatrixD &covMatrix){
+   //
+   // fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts
+   // returns chi2, fitParam and covMatrix
+   // returns TString with fitted formula
+   //
+   
+   TString formulaStr(formula); 
+   TString drawStr(drawCommand);
+   TString cutStr(cuts);
+   
+   // abbreviations:
+   drawStr.ReplaceAll("~",".fElements");
+   cutStr.ReplaceAll("~",".fElements");
+   formulaStr.ReplaceAll("~", ".fElements");
+   
+   formulaStr.ReplaceAll("++", "~");
+   TObjArray* formulaTokens = formulaStr.Tokenize("~"); 
+   Int_t dim = formulaTokens->GetEntriesFast();
+   
+   fitParam.ResizeTo(dim);
+   covMatrix.ResizeTo(dim,dim);
+   
+   TLinearFitter* fitter = new TLinearFitter(dim+1, Form("hyp%d",dim));
+   fitter->StoreData(kTRUE);   
+   fitter->ClearPoints();
+   
+   Int_t entries = Draw(drawStr.Data(), cutStr.Data(), "goff");
+   if (entries == -1) return new TString("An ERROR has occured during fitting!");
+   Double_t **values = new Double_t*[dim+1] ; 
+   
+   for (Int_t i = 0; i < dim + 1; i++){
+      Int_t centries = 0;
+      if (i < dim) centries = fTree->Draw(((TObjString*)formulaTokens->At(i))->GetName(), cutStr.Data(), "goff");
+      else  centries = fTree->Draw(drawStr.Data(), cutStr.Data(), "goff");
+      
+      if (entries != centries) return new TString("An ERROR has occured during fitting!");
+      values[i] = new Double_t[entries];
+      memcpy(values[i],  fTree->GetV1(), entries*sizeof(Double_t)); 
+   }
+   
+   // add points to the fitter
+   for (Int_t i = 0; i < entries; i++){
+      Double_t x[1000];
+      for (Int_t j=0; j<dim;j++) x[j]=values[j][i];
+      fitter->AddPoint(x, values[dim][i], 1);
+   }
+
+   fitter->Eval();
+   fitter->GetParameters(fitParam);
+   fitter->GetCovarianceMatrix(covMatrix);
+   chi2 = fitter->GetChisquare();
+   chi2 = chi2;
+   
+   TString *preturnFormula = new TString(Form("( %f+",fitParam[0])), &returnFormula = *preturnFormula; 
+   
+   for (Int_t iparam = 0; iparam < dim; iparam++) {
+     returnFormula.Append(Form("%s*(%f)",((TObjString*)formulaTokens->At(iparam))->GetName(),fitParam[iparam+1]));
+     if (iparam < dim-1) returnFormula.Append("+");
+   }
+   returnFormula.Append(" )");
+   delete formulaTokens;
+   delete fitter;
+   delete[] values;
+   return preturnFormula;
+}
+
+
+
 void AliTPCCalibViewer::MakeTreeWithObjects(const char * fileName, TObjArray * array, const char * mapFileName) {
   //
   // Write tree with all available information
index a7507b1..3100a11 100644 (file)
@@ -27,6 +27,7 @@ public:
    AliTPCCalibViewer(char* fileName, char* treeName = "calPads");
    AliTPCCalibViewer &operator = (const AliTPCCalibViewer & param);
    virtual ~AliTPCCalibViewer();
+   virtual void Delete(Option_t* option = "");
    
    virtual void     Draw(Option_t* opt="") { fTree->Draw(opt); }
    virtual Long64_t Draw(const char* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0) { return fTree->Draw(varexp, selection, option, nentries, firstentry); };
@@ -53,11 +54,15 @@ public:
    TFriendElement* AddFriend(const char* treename, const char* filename) {return fTree->AddFriend(treename, filename);};
    TFriendElement* AddFriend(TTree* tree, const char* alias, Bool_t warn=kFALSE) {return fTree->AddFriend(tree, alias, warn);};
    TFriendElement* AddFriend(const char* treename, TFile* file) {return fTree->AddFriend(treename, file);};
-   
+   TTree * GetTree() { return fTree;}
+
+   TString* Fit(const char* drawCommand, const char* formula, const char* cuts, Double_t & chi2, TVectorD &fitParam, TMatrixD &covMatrix);
+      
 protected:
    TTree* fTree;     // tree containing visualization data (e.g. written by AliTPCCalPad::MakeTree(...)
    TFile* fFile;     // file that contains a calPads tree (e.g. written by AliTPCCalPad::MakeTree(...)
    TObjArray* fListOfObjectsToBeDeleted;  //Objects, that will be deleted when the destructor ist called
+   Bool_t fTreeMustBeDeleted;  // decides weather the tree must be deleted in destructor or not 
    
    ClassDef(AliTPCCalibViewer,1)    //  TPC calibration viewer class
 };
index a72a1f2..f2480fa 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  GUI for the AliTPCCalibViewer                                            //
-//  used for the calibration monitor   
-//  Example usage: 
+//  used for the calibration monitor                                         //
+//  Example usage:                                                           //
 /*
   aliroot
-
-  AliTPCCalibViewerGUI v(gClient->GetRoot(), 1000, 600, "/u/sgaertne/calibration/localFit/AliTPCCalibViewer/allInOne6.root")
-
- - Resize windows - (BUG to BE FIXED)
-
-*/                                      //
+  AliTPCCalibViewerGUI::showGUI("allInOne22.root")
+*/
+// - Resize windows - (BUG to BE FIXED -> ROOT bug)                          //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TObjArray.h>
 #include <TObjString.h>
 #include <TVector.h>
+#include <string.h>
+#include <TH1.h>
+
 
 ClassImp(AliTPCCalibViewerGUI)
 
 AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h, char* fileName)
-  : TGMainFrame(p, w, h),
+  : TGCompositeFrame(p, w, h),
     fViewer(0),
-    fContAll(0),
+    fContTopBottom(0),
+    fContLCR(0),
     fContLeft(0),
     fContRight(0),
     fContCenter(0),
     fContPlotOpt(0),
     fContDrawOpt(0),
+    fContDrawOptSub1D2D(0),
     fContNormalized(0),
     fContCustom(0),
     fContCuts(0),
     fContSector(0),
     fContAddCuts(0),
+    fContFit(0),
+    fContAddFit(0),
+    fContScaling(0),
+    fContSetMax(0),
+    fContSetMin(0),
     fListVariables(0),
     fBtnDraw(0),
+    fBtnFit(0),
+    fBtnAddFitFunction(0),
+    fBtnGetMinMax(0),
     fCanvMain(0),
     fRadioRaw(0),
     fRadioNormalized(0),
+    fRadioPredefined(0),
     fRadioCustom(0),
     fRadio1D(0),
     fRadio2D(0),
@@ -72,10 +83,17 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
     fChkAuto(0),
     fComboMethod(0),
     fListNormalization(0),
-    fTxtCustom(0),
+    fComboCustom(0),
     fNmbSector(0),
+    fLblSector(0),
     fChkAddCuts(0),
-    fTxtAddCuts(0)
+    fComboAddCuts(0), 
+    fComboCustomFit(0),
+    fChkSetMax(0),
+    fChkSetMin(0),
+    fChkGetMinMaxAuto(0),
+    fTxtSetMax(0),
+    fTxtSetMin(0)
 //
 // AliTPCCalibViewerGUI constructor; fileName specifies the ROOT tree used for drawing
 //
@@ -84,59 +102,88 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
    
    // ************************* content of this MainFrame *************************
    // top level container with horizontal layout
-   fContAll = new TGCompositeFrame(this, w, h, kHorizontalFrame | kFixedWidth | kFixedHeight);
-   AddFrame(fContAll, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+   fContTopBottom = new TGCompositeFrame(this, w, h, kVerticalFrame | kFixedWidth | kFixedHeight);
+   AddFrame(fContTopBottom, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+   
+   fContLCR = new TGCompositeFrame(fContTopBottom, w, h, kHorizontalFrame | kFixedWidth | kFixedHeight);
+   fContTopBottom->AddFrame(fContLCR, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+   
 
-   // ************************* content of fContAll *************************
+   // ************************* content of fContLCR *************************
    // left container
-   fContLeft = new TGCompositeFrame(fContAll, 200, 200, kVerticalFrame | kFixedWidth | kFitHeight);
-   fContAll->AddFrame(fContLeft, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandY, 5, 3, 3, 3));
+   fContLeft = new TGCompositeFrame(fContLCR, 200, 200, kVerticalFrame | kFixedWidth | kFitHeight);
+   fContLCR->AddFrame(fContLeft, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandY, 5, 3, 3, 3));
    
    // left vertical splitter
-   TGVSplitter *splitLeft = new TGVSplitter(fContAll);
+   TGVSplitter *splitLeft = new TGVSplitter(fContLCR);
    splitLeft->SetFrame(fContLeft, kTRUE);
-   fContAll->AddFrame(splitLeft, new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 0, 0, 0, 0));
+   fContLCR->AddFrame(splitLeft, new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 0, 0, 0, 0));
 
    // right container
-   fContRight = new TGCompositeFrame(fContAll, 150, 200, kVerticalFrame | kFixedWidth | kFitHeight);
-   fContAll->AddFrame(fContRight, new TGLayoutHints(kLHintsTop | kLHintsRight | kLHintsExpandY, 3, 5, 3, 3));
+   fContRight = new TGCompositeFrame(fContLCR, 150, 200, kVerticalFrame | kFixedWidth | kFitHeight);
+   fContLCR->AddFrame(fContRight, new TGLayoutHints(kLHintsTop | kLHintsRight | kLHintsExpandY, 3, 5, 3, 3));
    
    // center container
-   fContCenter = new TGCompositeFrame(fContAll, 200, 200, kVerticalFrame | kFixedWidth | kFitHeight);
-   fContAll->AddFrame(fContCenter, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+   fContCenter = new TGCompositeFrame(fContLCR, 200, 200, kVerticalFrame | kFixedWidth | kFitHeight);
+   fContLCR->AddFrame(fContCenter, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
 
    // right vertical splitter
-   TGVSplitter *splitRight = new TGVSplitter(fContAll);
+   TGVSplitter *splitRight = new TGVSplitter(fContLCR);
    splitRight->SetFrame(fContRight, kFALSE);
-   fContAll->AddFrame(splitRight, new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 0, 0, 0, 0));
+   fContLCR->AddFrame(splitRight, new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 0, 0, 0, 0));
    
    // ************************* content of fContLeft *************************
+   // draw button
+   fBtnDraw = new TGTextButton(fContLeft, "&Draw");
+   fContLeft->AddFrame(fBtnDraw, new TGLayoutHints(kLHintsExpandX, 10, 10, 0, 0));
+   //fBtnDraw->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoTest(=\"fBtnDraw clicked\")");
+   fBtnDraw->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoDraw()");
+   
+   // draw options container
+   fContDrawOpt = new TGGroupFrame(fContLeft, "Plot options", kVerticalFrame | kFitWidth | kFitHeight);
+   fContLeft->AddFrame(fContDrawOpt, new TGLayoutHints(kLHintsExpandX, 0, 0, 10, 0));
+   fContDrawOptSub1D2D = new TGCompositeFrame(fContDrawOpt, 200, 20, kHorizontalFrame | kFitWidth | kFixedHeight);
+   fContDrawOpt->AddFrame(fContDrawOptSub1D2D, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   
+   
+   // predefined radio button
+   fRadioPredefined = new TGRadioButton(fContLeft, "Predefined: ", 13);
+   fContLeft->AddFrame(fRadioPredefined, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   fRadioPredefined->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
+   
    // list of variables
    fListVariables = new TGListBox(fContLeft);
-   fContLeft->AddFrame(fListVariables, new TGLayoutHints(kLHintsNormal | kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+   fContLeft->AddFrame(fListVariables, new TGLayoutHints(kLHintsNormal | kLHintsExpandX | kLHintsExpandY, 10, 0, 0, 0));
    fListVariables->Connect("Selected(Int_t)", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
 
    // plot options container
    //fContPlotOpt = new TGCompositeFrame(fContLeft, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
-   fContPlotOpt = new TGGroupFrame(fContLeft, "Plot options", kVerticalFrame | kFitWidth | kFitHeight);
-   fContLeft->AddFrame(fContPlotOpt, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
-
-   // draw options container
-   fContDrawOpt = new TGCompositeFrame(fContLeft, 200, 20, kHorizontalFrame | kFitWidth | kFixedHeight);
-   fContLeft->AddFrame(fContDrawOpt, new TGLayoutHints(kLHintsExpandX, 0, 0, 10, 0));
-   
-   // draw button
-   fBtnDraw = new TGTextButton(fContLeft, "&Draw");
-   fContLeft->AddFrame(fBtnDraw, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
-   //fBtnDraw->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoTest(=\"fBtnDraw clicked\")");
-   fBtnDraw->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoDraw()");
+   fContPlotOpt = new TGGroupFrame(fContLeft, "Normalization options", kVerticalFrame | kFitWidth | kFitHeight);
+   fContLeft->AddFrame(fContPlotOpt, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10, 0, 0, 0));
    
+   // custom radio button
+   fRadioCustom = new TGRadioButton(fContLeft, "Custom: ", 12);
+   fContLeft->AddFrame(fRadioCustom, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   fRadioCustom->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
+
+   // custom options container
+   fContCustom = new TGCompositeFrame(fContTopBottom, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
+   fContTopBottom->AddFrame(fContCustom, new TGLayoutHints(kLHintsExpandX, 10, 0, 0, 0));
+
    // ************************* content of fContRight *************************
    // cut options container
    //fContCuts = new TGCompositeFrame(fContRight, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
    fContCuts = new TGGroupFrame(fContRight, "Cuts", kVerticalFrame | kFitWidth | kFitHeight);
    fContRight->AddFrame(fContCuts, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
 
+   // Fit options container
+   fContFit = new TGGroupFrame(fContRight, "Custom Fit", kVerticalFrame | kFitWidth | kFitHeight);
+   fContRight->AddFrame(fContFit, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   
+   // Scaling options container
+   fContScaling = new TGGroupFrame(fContRight, "Scaling", kVerticalFrame | kFitWidth | kFitHeight);
+   fContRight->AddFrame(fContScaling, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   
    // ************************* content of fContCenter *************************
    // main drawing canvas
    fCanvMain = new TRootEmbeddedCanvas("Main Canvas", fContCenter, 200, 200, kFitWidth | kFitHeight);
@@ -161,24 +208,16 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
    fContNormalized = new TGCompositeFrame(fContPlotOpt, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
    fContPlotOpt->AddFrame(fContNormalized, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 15, 0, 0, 0));
 
-   // custom radio button
-   fRadioCustom = new TGRadioButton(fContPlotOpt, "Custom", 12);
-   fContPlotOpt->AddFrame(fRadioCustom, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
-   fRadioCustom->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
-
-   // custom options container
-   fContCustom = new TGCompositeFrame(fContPlotOpt, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
-   fContPlotOpt->AddFrame(fContCustom, new TGLayoutHints(kLHintsExpandX, 15, 0, 0, 0));
-
    // ************************* content of fContDrawOpt *************************
    // 1D radio button
-   fRadio1D = new TGRadioButton(fContDrawOpt, "1D", 30);
-   fContDrawOpt->AddFrame(fRadio1D, new TGLayoutHints(kLHintsNormal, 2, 2, 0, 0));
+   fRadio1D = new TGRadioButton(fContDrawOptSub1D2D, "1D", 30);
+//   fContDrawOpt->AddFrame(fRadio1D, new TGLayoutHints(kLHintsNormal, 2, 2, 0, 0));
+   fContDrawOptSub1D2D->AddFrame(fRadio1D, new TGLayoutHints(kLHintsNormal, 2, 2, 0, 0));
    fRadio1D->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
    
    // 2D radio button
-   fRadio2D = new TGRadioButton(fContDrawOpt, "2D", 31);
-   fContDrawOpt->AddFrame(fRadio2D, new TGLayoutHints(kLHintsNormal, 2, 2, 0, 0));
+   fRadio2D = new TGRadioButton(fContDrawOptSub1D2D, "2D", 31);
+   fContDrawOptSub1D2D->AddFrame(fRadio2D, new TGLayoutHints(kLHintsNormal, 2, 2, 0, 0));
    fRadio2D->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
 
    // automatic redraw check button
@@ -207,8 +246,8 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
    fRadioSector->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
 
    // sector options container
-   fContSector = new TGCompositeFrame(fContCuts, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
-   fContCuts->AddFrame(fContSector, new TGLayoutHints(kLHintsExpandX, 15, 0, 0, 0));
+   fContSector = new TGCompositeFrame(fContCuts, 200, 200, kHorizontalFrame | kFitWidth | kFitHeight);
+   fContCuts->AddFrame(fContSector, new TGLayoutHints(kLHintsExpandX, 5, 0, 0, 0));
    
    // additional cuts check button
    fChkAddCuts = new TGCheckButton(fContCuts, "additional cuts");
@@ -217,7 +256,7 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
 
    // additional cuts container
    fContAddCuts = new TGCompositeFrame(fContCuts, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
-   fContCuts->AddFrame(fContAddCuts, new TGLayoutHints(kLHintsExpandX, 15, 0, 0, 0));
+   fContCuts->AddFrame(fContAddCuts, new TGLayoutHints(kLHintsExpandX, -5, -5, 0, 0));
    
    // ************************* content of fContNormalized *************************
    // method drop down combo box
@@ -233,22 +272,99 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
 
    // ************************* content of fContCustom *************************
    // text field for custom draw command
-   fTxtCustom = new TGTextEntry(fContCustom);
-   fContCustom->AddFrame(fTxtCustom, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
-   fTxtCustom->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
+   fComboCustom = new TGComboBox(fContCustom);
+   fComboCustom->Resize(0, fBtnDraw->GetDefaultHeight());
+   fComboCustom->EnableTextInput(kTRUE);
+   fContCustom->AddFrame(fComboCustom, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
+   fComboCustom->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "HandleButtons(=42)");
+   fComboCustom->Connect("Selected(Int_t)", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
    
    // ************************* content of fContSector *************************
    // sector number entry
    fNmbSector = new TGNumberEntry(fContSector, 0, 1, -1, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative, TGNumberFormat::kNELLimitMinMax, 0, 71);
    fContSector->AddFrame(fNmbSector, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
-   fNmbSector->Connect("ValueSet(Long_t)", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
+   fNmbSector->Connect("ValueSet(Long_t)", "AliTPCCalibViewerGUI", this, "ChangeSector()");
+   
+   // sector number label
+   fLblSector = new TGLabel(fContSector, "IROC, A");
+   fContSector->AddFrame(fLblSector, new TGLayoutHints(kLHintsNormal | kLHintsExpandX));
    
    // ************************* content of fContAddCuts *************************
-   // text field for additional cuts
-   fTxtAddCuts = new TGTextEntry(fContAddCuts);
-   fContAddCuts->AddFrame(fTxtAddCuts, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
-   fTxtAddCuts->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
+   // combo text field for additional cuts
+   fComboAddCuts = new TGComboBox(fContAddCuts);
+   fComboAddCuts->Resize(0, fBtnDraw->GetDefaultHeight());
+   fComboAddCuts->EnableTextInput(kTRUE);
+   fContAddCuts->AddFrame(fComboAddCuts, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
+   fComboAddCuts->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
+   fComboAddCuts->Connect("Selected(Int_t)", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
+   
+   // ************************* content of fContFit *************************
+   // container for additional fits
+   fContAddFit = new TGCompositeFrame(fContFit, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
+   fContFit->AddFrame(fContAddFit, new TGLayoutHints(kLHintsExpandX, -5, -5, 0, 0));
+   
+   // ************************* content of fContAddFit *************************
+   // text field for custom fit
+   fComboCustomFit = new TGComboBox(fContAddFit);
+   fComboCustomFit->Resize(0, fBtnDraw->GetDefaultHeight());
+   fComboCustomFit->EnableTextInput(kTRUE);
+   fContAddFit->AddFrame(fComboCustomFit, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
+   fComboCustomFit->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "DoFit()");
+   fComboCustomFit->Connect("Selected(Int_t)", "AliTPCCalibViewerGUI", this, "DoFit()");
+   
+   // fit button
+   fBtnFit = new TGTextButton(fContAddFit, "&Fit");
+   fContAddFit->AddFrame(fBtnFit, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   fBtnFit->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoFit()");
+
+   // add fit function button
+   //fBtnAddFitFunction = new TGTextButton(fContAddFit, "&Add fit function to normalization");
+   //fContAddFit->AddFrame(fBtnAddFitFunction, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   //fBtnAddFitFunction->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "AddFitFunction()");
+
+   // ************************* content of fContScaling *************************
+   // SetMaximum container
+   fContSetMax = new TGCompositeFrame(fContScaling, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
+   fContScaling->AddFrame(fContSetMax, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+
+   // SetMinimum container
+   fContSetMin = new TGCompositeFrame(fContScaling, 200, 200, kVerticalFrame | kFitWidth | kFitHeight);
+   fContScaling->AddFrame(fContSetMin, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   
+   // get Min & Max from Plot - button
+   fBtnGetMinMax = new TGTextButton(fContScaling, "&Get scale from plot");
+   fContScaling->AddFrame(fBtnGetMinMax, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
+   fBtnGetMinMax->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "GetMinMax()");
+   
+   // GetMinMaxAuto - checkbox
+   fChkGetMinMaxAuto = new TGCheckButton(fContScaling, "Get Min + Max auto.");
+   fContScaling->AddFrame(fChkGetMinMaxAuto, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
+   fChkGetMinMaxAuto->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
 
+   
+   // ************************* content of fContSetMax *************************
+   // SetMaximum - checkbox
+   fChkSetMax = new TGCheckButton(fContSetMax, "Set fixed max.");
+   fContSetMax->AddFrame(fChkSetMax, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
+   fChkSetMax->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
+   
+   // text field for maximum value
+   fTxtSetMax = new TGTextEntry(fContSetMax, "", 41);
+   fContSetMax->AddFrame(fTxtSetMax, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
+   fTxtSetMax->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
+
+   // ************************* content of fContSetMin *************************
+   // SetMinimum - checkbox
+   fChkSetMin = new TGCheckButton(fContSetMin, "Set fixed min.");
+   fContSetMin->AddFrame(fChkSetMin, new TGLayoutHints(kLHintsNormal, 0, 0, 0, 0));
+   fChkSetMin->Connect("Clicked()", "AliTPCCalibViewerGUI", this, "DoNewSelection()");
+   
+   // text field for minimum value
+   fTxtSetMin = new TGTextEntry(fContSetMin, "", 40);
+   fContSetMin->AddFrame(fTxtSetMin, new TGLayoutHints(kLHintsNormal | kLHintsExpandX, 0, 0, 0, 0));
+   fTxtSetMin->Connect("ReturnPressed()", "AliTPCCalibViewerGUI", this, "HandleButtons()");
+
+   
    // Display everything
    Initialize(fileName);
    SetWindowName("AliTPCCalibViewer GUI");
@@ -258,24 +374,35 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h
 }
 
 AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const AliTPCCalibViewerGUI &c)
-   : TGMainFrame(c.fParent, c.fWidth, c.fHeight),
+   : TGCompositeFrame(c.fParent, c.fWidth, c.fHeight),
     fViewer(0),
-    fContAll(0),
+    fContTopBottom(0),
+    fContLCR(0),
     fContLeft(0),
     fContRight(0),
     fContCenter(0),
     fContPlotOpt(0),
     fContDrawOpt(0),
+    fContDrawOptSub1D2D(0),
     fContNormalized(0),
     fContCustom(0),
     fContCuts(0),
     fContSector(0),
     fContAddCuts(0),
+    fContFit(0),
+    fContAddFit(0),
+    fContScaling(0),
+    fContSetMax(0),
+    fContSetMin(0),
     fListVariables(0),
     fBtnDraw(0),
+    fBtnFit(0),
+    fBtnAddFitFunction(0),
+    fBtnGetMinMax(0),
     fCanvMain(0),
     fRadioRaw(0),
     fRadioNormalized(0),
+    fRadioPredefined(0),
     fRadioCustom(0),
     fRadio1D(0),
     fRadio2D(0),
@@ -286,10 +413,17 @@ AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const AliTPCCalibViewerGUI &c)
     fChkAuto(0),
     fComboMethod(0),
     fListNormalization(0),
-    fTxtCustom(0),
+    fComboCustom(0),
     fNmbSector(0),
+    fLblSector(0),
     fChkAddCuts(0),
-    fTxtAddCuts(0)
+    fComboAddCuts(0), 
+    fComboCustomFit(0),
+    fChkSetMax(0),
+    fChkSetMin(0),
+    fChkGetMinMaxAuto(0),
+    fTxtSetMax(0),
+    fTxtSetMin(0)
 {
   //
   // dummy AliTPCCalibViewerGUI copy constructor
@@ -304,12 +438,21 @@ AliTPCCalibViewerGUI & AliTPCCalibViewerGUI::operator =(const AliTPCCalibViewerG
 }
 
 AliTPCCalibViewerGUI::~AliTPCCalibViewerGUI() {
+   if (fCanvMain && fCanvMain->GetCanvas()) {
+      for (Int_t i = 0; i < fCanvMain->GetCanvas()->GetListOfPrimitives()->GetEntries(); i++) {
+         if (strcmp(fCanvMain->GetCanvas()->GetListOfPrimitives()->At(i)->ClassName(), "TFrame") != 0)
+            fCanvMain->GetCanvas()->GetListOfPrimitives()->At(i)->Delete();
+      }
+   }
    Cleanup();
+   if (fViewer) fViewer->Delete();
 }
 
+/*
 void AliTPCCalibViewerGUI::CloseWindow() {
    DeleteWindow();
 }
+*/
 
 void AliTPCCalibViewerGUI::Initialize(char* fileName) {
    //
@@ -317,6 +460,7 @@ void AliTPCCalibViewerGUI::Initialize(char* fileName) {
    //
    
    // create AliTPCCalibViewer object, which will be used for generating all drawings
+   if (fViewer) delete fViewer;
    fViewer = new AliTPCCalibViewer(fileName);
 
    // fill fListVariables
@@ -325,7 +469,7 @@ void AliTPCCalibViewerGUI::Initialize(char* fileName) {
    iter->Reset();
    TObjString* currentStr = 0;
    Int_t id = 0;
-   while (currentStr = (TObjString*)(iter->Next())) {
+   while ((currentStr = (TObjString*)(iter->Next()))) {
       fListVariables->AddEntry(currentStr->GetString().Data(), id);
       id++;
    }
@@ -343,7 +487,7 @@ void AliTPCCalibViewerGUI::Initialize(char* fileName) {
    iter->Reset();
    currentStr = 0;
    id = 0;
-   while (currentStr = (TObjString*)(iter->Next())) {
+   while ((currentStr = (TObjString*)(iter->Next()))) {
       fListNormalization->AddEntry(currentStr->GetString().Data(), id);
       id++;
    }
@@ -352,15 +496,24 @@ void AliTPCCalibViewerGUI::Initialize(char* fileName) {
    delete arr;
 
    // set default button states
+   fRadioPredefined->SetState(kButtonDown);
    fRadioRaw->SetState(kButtonDown);
    fRadioTPC->SetState(kButtonDown);
-   //fRadioCustom->SetState(kButtonDisabled);
    fRadio1D->SetState(kButtonDown);
    fChkAuto->SetState(kButtonDown);
    fChkAddCuts->SetState(kButtonUp);
    fListVariables->Select(0);
    fListNormalization->Select(0);
    fComboMethod->Select(0);
+   fChkGetMinMaxAuto->SetState(kButtonDown);
+   fChkSetMin->SetState(kButtonUp);
+   fChkSetMax->SetState(kButtonUp);
+
+   //fCanvMain->GetCanvas()->ToggleEventStatus(); // klappt nicht
+   //fCanvMain->GetCanvas()->GetCanvasImp()->ShowStatusBar(kTRUE); // klappt auch nicht
+   fListVariables->IntegralHeight(kFALSE);         // naja
+   fListNormalization->IntegralHeight(kFALSE);     // naja
+   DoDraw();
 }
 
 void AliTPCCalibViewerGUI::HandleButtons(Int_t id) {
@@ -371,21 +524,27 @@ void AliTPCCalibViewerGUI::HandleButtons(Int_t id) {
       TGButton *btn = (TGButton *) gTQSender;
       id = btn->WidgetId();
    }
-   
+
    switch (id) {
       case 10:             // fRadioRaw
          fRadioNormalized->SetState(kButtonUp);
+         fRadioPredefined->SetState(kButtonDown);
          fRadioCustom->SetState(kButtonUp);
          //fComboMethod->UnmapWindow();
          //fListNormalization->UnmapWindow();
          break;
       case 11:             // fRadioNormalized
          fRadioRaw->SetState(kButtonUp);
+         fRadioPredefined->SetState(kButtonDown);
          fRadioCustom->SetState(kButtonUp);
          break;
       case 12:             // fRadioCustom
-         fRadioRaw->SetState(kButtonUp);
-         fRadioNormalized->SetState(kButtonUp);
+         fRadioPredefined->SetState(kButtonUp);
+         //fRadioNormalized->SetState(kButtonUp);
+         break;
+      case 13:             // fRadioPredefined
+         fRadioCustom->SetState(kButtonUp);
+         //fRadioNormalized->SetState(kButtonUp);
          break;
       //--------
       case 20:             // fRadioTPC
@@ -415,10 +574,19 @@ void AliTPCCalibViewerGUI::HandleButtons(Int_t id) {
       case 31:             // fRadio2D
          fRadio1D->SetState(kButtonUp);
          break;
+      //--------
+      case 40:             // fTxtSetMin
+         fChkSetMin->SetState(kButtonDown);
+         break;
+      case 41:             // fTxtSetMax
+         fChkSetMax->SetState(kButtonDown);
+         break;
+      case 42:             // fComboCustom
+         fRadioCustom->SetState(kButtonDown);
+         fRadioPredefined->SetState(kButtonUp);
+         break;
    }
-   //fRadioCustom->SetState(kButtonDisabled);
-
-   if (fChkAuto->GetState() == kButtonDown) DoDraw();
+   DoNewSelection();
 }
 
 void AliTPCCalibViewerGUI::DoNewSelection() {
@@ -436,11 +604,12 @@ void AliTPCCalibViewerGUI::DoDraw() {
    
    // specify data to plot
    TString desiredData("");
+   if (!fListVariables->GetSelectedEntry()) return;
    desiredData += ((TGTextLBEntry*)(fListVariables->GetSelectedEntry()))->GetTitle();
    desiredData += ".fElements";
 
    // specify normalization
-   if (fRadioNormalized->GetState() == kButtonDown) {
+   if (fRadioPredefined->GetState() == kButtonDown && fRadioNormalized->GetState() == kButtonDown) {
       TString op("");
       switch (fComboMethod->GetSelected()) {
          case 0:        // subtraction
@@ -451,14 +620,46 @@ void AliTPCCalibViewerGUI::DoDraw() {
             break;
       }
       TString normalizationData("");
+      if (!fListNormalization->GetSelectedEntry()) return;
       normalizationData += ((TGTextLBEntry*)(fListNormalization->GetSelectedEntry()))->GetTitle();
+      
+      if ( normalizationData.BeginsWith("Fit")) {
+         // create fit formula, evaluate it an replace normalizationData-String
+         // ********** create cut string **********
+         TString cutStr("");
+         if (fRadioTPC->GetState() == kButtonDown)
+            cutStr += ""; // whole TPC is used for fitting
+         if (fRadioSideA->GetState() == kButtonDown)
+            cutStr += "(sector/18)%2==0"; // side A
+         if (fRadioSideC->GetState() == kButtonDown)
+            cutStr+= "(sector/18)%2==1"; // side C
+         if (fRadioSector->GetState() == kButtonDown) {
+            Int_t sector = (Int_t)(fNmbSector->GetNumber());
+            cutStr += "sector==";
+            cutStr += sector; 
+         }
+         if (fChkAddCuts->GetState() == kButtonDown && strcmp(fComboAddCuts->GetTextEntry()->GetText(), "") != 0){
+            if (fRadioTPC->GetState() != kButtonDown) cutStr += " && ";
+            cutStr += fComboAddCuts->GetTextEntry()->GetText();  
+         }
+         Double_t chi2 = 0;
+         TVectorD fitParam(0);
+         TMatrixD covMatrix(0,0);
+         TString formulaStr("");
+         if (normalizationData.CompareTo("FitLinLocal") == 0)
+            formulaStr = "lx~ ++ ly~";
+         if (normalizationData.CompareTo("FitLinGlobal") == 0) 
+            formulaStr = "gx~ ++ gy~";
+         normalizationData = *fViewer->Fit(desiredData.Data(), formulaStr.Data(), cutStr.Data(), chi2, fitParam, covMatrix);
+      }
+
       desiredData += op;
-      desiredData += ((TGTextLBEntry*)(fListVariables->GetSelectedEntry()))->GetTitle();
-      //desiredData += "_";
+      if (! (TString(((TGTextLBEntry*)(fListNormalization->GetSelectedEntry()))->GetTitle())).BeginsWith("Fit"))
+         desiredData += ((TGTextLBEntry*)(fListVariables->GetSelectedEntry()))->GetTitle();
       desiredData += normalizationData;
    }
    else if (fRadioCustom->GetState() == kButtonDown) {
-      desiredData = fTxtCustom->GetText();
+      desiredData = fComboCustom->GetTextEntry()->GetText();
       if (desiredData == "") return;
    }
 
@@ -476,15 +677,188 @@ void AliTPCCalibViewerGUI::DoDraw() {
    }
    TString cutsStr("");
    if (fChkAddCuts->GetState() == kButtonDown)
-      cutsStr += fTxtAddCuts->GetText();
+      cutsStr += fComboAddCuts->GetTextEntry()->GetText();
    
    // draw finally
+   for (Int_t i = 0; i < fCanvMain->GetCanvas()->GetListOfPrimitives()->GetEntries(); i++) {
+      if (strcmp(fCanvMain->GetCanvas()->GetListOfPrimitives()->At(i)->ClassName(), "TFrame") != 0)
+         fCanvMain->GetCanvas()->GetListOfPrimitives()->At(i)->Delete();
+   }
+   //fCanvMain->GetCanvas()->Clear();
    fCanvMain->GetCanvas()->cd();
-   //fViewer->Draw(desiredData.Data(), cuts.Data());
+   Int_t entries = -1;
    if (fRadio1D->GetState() == kButtonDown)
-      fViewer->EasyDraw1D(desiredData.Data(), sectorStr.Data(), cutsStr.Data());
+      entries = fViewer->EasyDraw1D(desiredData.Data(), sectorStr.Data(), cutsStr.Data());
    else if (fRadio2D->GetState() == kButtonDown)
-      fViewer->EasyDraw(desiredData.Data(), sectorStr.Data(), cutsStr.Data());
+      entries = fViewer->EasyDraw(desiredData.Data(), sectorStr.Data(), cutsStr.Data());
+   if (entries == -1) return;
+   
+   TList* listOfPrimitives = fCanvMain->GetCanvas()->GetListOfPrimitives();
+   TObject* ptr = 0;
+   for (Int_t i = 0; i < listOfPrimitives->GetEntries(); i++) {
+      ptr = listOfPrimitives->At(i);
+      if ( ptr->InheritsFrom("TH1") ) break;
+   }
+   if ( ptr != 0 && !ptr->InheritsFrom("TH1") ) return;      // if the loop did not find a TH1
+   TH1 *hist = (TH1*)ptr; 
+   TString minTxt(fTxtSetMin->GetText());
+   TString maxTxt(fTxtSetMax->GetText());
+   if (fChkSetMax->GetState() == kButtonDown && (maxTxt.IsDigit() || maxTxt.IsFloat()) )
+      hist->SetMaximum(maxTxt.Atof());
+   if (fChkSetMin->GetState() == kButtonDown && (minTxt.IsDigit() || minTxt.IsFloat()) )
+      hist->SetMinimum(minTxt.Atof());
+      
+   if (fChkGetMinMaxAuto->GetState() == kButtonDown) {
+      if (fChkSetMax->GetState() == kButtonUp)
+         fTxtSetMax->SetText(Form("%f", hist->GetMaximum()));
+      if (fChkSetMin->GetState() == kButtonUp)
+         fTxtSetMin->SetText(Form("%f", hist->GetMinimum()));
+   }
    
    fCanvMain->GetCanvas()->Update();
 }
+
+
+void AliTPCCalibViewerGUI::DoFit() {
+   //
+   // main method for fitting
+   //
+   
+   Double_t chi2 = 0;
+   TVectorD fitParam(0);
+   TMatrixD covMatrix(0,0);
+   TString drawStr("");
+   TString cutStr("");
+   TString formulaStr("");
+   TString *returnStr = new TString("");
+
+   
+   // ******** create draw string *********
+   if (fRadioCustom->GetState() == kButtonDown) {
+   // take custom text as draw string
+      drawStr = fComboCustom->GetTextEntry()->GetText();
+      if (drawStr == "") return;
+   }
+   else if (fRadioPredefined->GetState() == kButtonDown) {
+   // create drawStr out of selection
+      drawStr += ((TGTextLBEntry*)(fListVariables->GetSelectedEntry()))->GetTitle();
+      drawStr += ".fElements";
+      if (fRadioNormalized->GetState() == kButtonDown) {
+      // normalize data by selection
+         TString op("");
+         switch (fComboMethod->GetSelected()) {
+            case 0:        // subtraction
+               op += "-";
+               break;
+            case 1:        // division
+               op += "/";
+               break;
+         }
+         TString normalizationData("");
+         normalizationData += ((TGTextLBEntry*)(fListNormalization->GetSelectedEntry()))->GetTitle();
+         drawStr += op;
+         drawStr += ((TGTextLBEntry*)(fListVariables->GetSelectedEntry()))->GetTitle();
+         drawStr += normalizationData;
+      }
+   }
+
+   // ********** create cut string **********
+   if (fRadioTPC->GetState() == kButtonDown)
+      cutStr += ""; // whole TPC is used for fitting
+   if (fRadioSideA->GetState() == kButtonDown)
+      cutStr += "(sector/18)%2==0"; // side A
+   if (fRadioSideC->GetState() == kButtonDown)
+      cutStr+= "(sector/18)%2==1"; // side C
+   if (fRadioSector->GetState() == kButtonDown) {
+      Int_t sector = (Int_t)(fNmbSector->GetNumber());
+      cutStr += "sector==";
+      cutStr += sector; 
+   }
+   if (fChkAddCuts->GetState() == kButtonDown && strcmp(fComboAddCuts->GetTextEntry()->GetText(), "") != 0){
+      if (fRadioTPC->GetState() != kButtonDown) cutStr += " && ";
+      cutStr += fComboAddCuts->GetTextEntry()->GetText();  
+   }
+   
+   // ********** get formula string **********
+   formulaStr += fComboCustomFit->GetTextEntry()->GetText();
+
+   // ********** call AliTPCCalibViewer's fit-function
+   returnStr = fViewer->Fit(drawStr.Data(), formulaStr.Data(), cutStr.Data(), chi2, fitParam, covMatrix);
+   
+   std::cout << std::endl;
+   std::cout << "Your fit formula reads as follows:" << std::endl;
+   std::cout << returnStr->Data() << std::endl;
+   std::cout << "chi2 = " << chi2 << std::endl;
+}
+
+void AliTPCCalibViewerGUI::GetMinMax() {
+   //
+   // Read current Min & Max from the plot and set it to fTxtSetMin & fTxtSetMax
+   //
+   TList* listOfPrimitives = fCanvMain->GetCanvas()->GetListOfPrimitives();
+   TObject* ptr = 0;
+   for (Int_t i = 0; i < listOfPrimitives->GetEntries(); i++) {
+      ptr = listOfPrimitives->At(i);
+      if ( ptr->InheritsFrom("TH1") ) break;
+   }
+   if ( ptr != 0 && !ptr->InheritsFrom("TH1") ) return;      // if the loop did not find a TH1
+   TH1 *hist = (TH1*)ptr;
+   Double_t histMax = hist->GetMaximum();
+   Double_t histMin = hist->GetMinimum();
+   fTxtSetMax->SetText(Form("%f",histMax));
+   fTxtSetMin->SetText(Form("%f",histMin));
+}
+
+void AliTPCCalibViewerGUI::ChangeSector(){
+   // 
+   // function that is called, when the number of the sector is changed
+   // to change the sector label
+   // 
+   Int_t sector = (Int_t)(fNmbSector->GetNumber());
+   char* secLabel = "";
+   if (sector >= 0 && sector <= 17) // IROC, Side A
+      secLabel = "IROC, A";
+   if (sector >= 18 && sector <= 35) // IROC, Side C
+      secLabel = "IROC, C";
+   if (sector >= 36 && sector <= 53) // OROC, Side A
+      secLabel = "OROC, A";
+   if (sector >= 54 && sector <= 71) // OROC, Side C
+      secLabel = "OROC, C";
+   fLblSector->SetText(secLabel);
+   DoNewSelection();
+}
+
+void AliTPCCalibViewerGUI::AddFitFunction(){ 
+   //
+   // adds the last fit function to the normalization list
+   // 
+   std::cout << "Not yet implemented." << std::endl;
+}
+   
+
+void AliTPCCalibViewerGUI::ShowGUI(const char* fileName) {
+   //
+   // initialize and show GUI for presentation
+   // 
+   TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
+   frmMain->SetWindowName("AliTPCCalibViewer GUI");
+   frmMain->SetCleanup(kDeepCleanup);
+   
+   TGTab* tabMain = new TGTab(frmMain, 1000, 600);
+   frmMain->AddFrame(tabMain, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+
+   TGCompositeFrame* tabCont1 = tabMain->AddTab("Viewer 1");
+   TGCompositeFrame* tabCont2 = tabMain->AddTab("Viewer 2");
+   
+   AliTPCCalibViewerGUI* calibViewer1 = new AliTPCCalibViewerGUI(tabCont1, 1000, 600, (char*)fileName);
+   tabCont1->AddFrame(calibViewer1, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+
+   AliTPCCalibViewerGUI* calibViewer2 = new AliTPCCalibViewerGUI(tabCont2, 1000, 600, (char*)fileName);
+   tabCont2->AddFrame(calibViewer2, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));
+   
+   frmMain->MapSubwindows();
+   frmMain->Resize();
+   frmMain->MapWindow();
+
+}
+
index deaf016..2e432fb 100644 (file)
 #include <TRootEmbeddedCanvas.h>
 #include <TGSplitter.h>
 #include <TGButtonGroup.h>
+#include <TGLabel.h>
+#include <TGTab.h>
+
 
 #include <iostream>
 #include "AliTPCCalibViewer.h"
 
 
-class AliTPCCalibViewerGUI : public TGMainFrame {
+class AliTPCCalibViewerGUI : public TGCompositeFrame {
 protected:
    AliTPCCalibViewer   *fViewer;             // CalibViewer object used for drawing
 
-   TGCompositeFrame    *fContAll;            // container for all GUI elements
+   TGCompositeFrame    *fContTopBottom;      // container for all GUI elements, vertical divided
+   TGCompositeFrame    *fContLCR;            // container for all GUI elements, horizontal divided
    TGCompositeFrame    *fContLeft;           // container for GUI elements on left side
    TGCompositeFrame    *fContRight;          // container for GUI elements on right side
    TGCompositeFrame    *fContCenter;         // container for GUI elements at the center
    TGCompositeFrame    *fContPlotOpt;        // container for plot options GUI elements
    TGCompositeFrame    *fContDrawOpt;        // container for draw options GUI elements
+   TGCompositeFrame    *fContDrawOptSub1D2D; // container for 1D and 2D radio-button
    TGCompositeFrame    *fContNormalized;     // container for normalization options GUI elements
    TGCompositeFrame    *fContCustom;         // container for custom draw command GUI elements
    TGCompositeFrame    *fContCuts;           // container for cut options GUI elements
    TGCompositeFrame    *fContSector;         // container for sector GUI elements
    TGCompositeFrame    *fContAddCuts;        // container for additional cut command GUI elements
+   TGCompositeFrame    *fContFit;            // container for fit GUI elements
+   TGCompositeFrame    *fContAddFit;         // container for additional fit GUI elements
+   TGCompositeFrame    *fContScaling;        // container for scaling GUI elements
+   TGCompositeFrame    *fContSetMax;         // container for SetMaximum elements
+   TGCompositeFrame    *fContSetMin;         // container for SetMinimum elements
    TGListBox           *fListVariables;      // listbox with possible variables
    TGTextButton        *fBtnDraw;            // draw button
+   TGTextButton        *fBtnFit;             // fit button
+   TGTextButton        *fBtnAddFitFunction;  // button to add fit function to normalization
+   TGTextButton        *fBtnGetMinMax;       // GetMinMax-button
    TRootEmbeddedCanvas *fCanvMain;           // main drawing canvas
    TGRadioButton       *fRadioRaw;           // raw radio button
    TGRadioButton       *fRadioNormalized;    // normalized radio button
+   TGRadioButton       *fRadioPredefined;    // predefined plot radio button
    TGRadioButton       *fRadioCustom;        // custom radio button
    TGRadioButton       *fRadio1D;            // 1D radio button
    TGRadioButton       *fRadio2D;            // 2D radio button
@@ -62,10 +76,18 @@ protected:
    TGCheckButton       *fChkAuto;            // automatic redraw checkbox
    TGComboBox          *fComboMethod;        // normalization methods dropdown box
    TGListBox           *fListNormalization;  // listbox with possible normalization variables
-   TGTextEntry         *fTxtCustom;          // text box for custom draw command
+   TGComboBox          *fComboCustom;        // combo box for custom draw commands
    TGNumberEntry       *fNmbSector;          // number entry box for specifying the sector
+   TGLabel             *fLblSector;          // label that shows the active sector
    TGCheckButton       *fChkAddCuts;         // additional cuts check box
-   TGTextEntry         *fTxtAddCuts;         // additional cuts text box
+   TGComboBox          *fComboAddCuts;       // additional cuts combo box
+   TGComboBox          *fComboCustomFit;     // custom fit combo box
+   TGCheckButton       *fChkSetMax;          // Set maximum check box
+   TGCheckButton       *fChkSetMin;          // Set maximum check box
+   TGCheckButton       *fChkGetMinMaxAuto;   // Get Min & Max automatically from plot
+   TGTextEntry         *fTxtSetMax;          // custom maximum text box
+   TGTextEntry         *fTxtSetMin;          // custom minimum text box
+   
 
    void Initialize(char* fileName);          // initializes the GUI with default settings and opens tree for drawing
    
@@ -75,11 +97,16 @@ public:
    AliTPCCalibViewerGUI &operator = (const AliTPCCalibViewerGUI &param);         // assignment operator
 
    virtual ~AliTPCCalibViewerGUI();
-   virtual void CloseWindow();
+   // virtual void CloseWindow();
 
    void HandleButtons(Int_t id = -1);        // handles mutual radio button exclusions
    void DoNewSelection();                    // decides whether to redraw if user makes another selection
    void DoDraw();                            // main method for drawing according to user selection
+   void DoFit();                             // main method for fitting
+   void GetMinMax();                         // Read current Min & Max from the plot and set it to fTxtSetMin & fTxtSetMax
+   void ChangeSector();                      // function that is called, when the number of the sector is changed
+   void AddFitFunction();                    // adds the last fit function to the normalization list
+   static void ShowGUI(const char* fileName); //initialize and show GUI for presentation
    ClassDef(AliTPCCalibViewerGUI, 0)
 };