Update of TPC RAW QA for improving DQM (see documentation in classes for
authormarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 Jun 2010 05:53:54 +0000 (05:53 +0000)
committermarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 22 Jun 2010 05:53:54 +0000 (05:53 +0000)
details).

Peter Christiansen

TPC/AliTPCQADataMakerRec.cxx
TPC/AliTPCQADataMakerRec.h
TPC/AliTPCdataQA.cxx
TPC/AliTPCdataQA.h

index 1ef3b42b17da140ddf064c4b44efea1c02e36aff..5155fb550a927b62f431df342530ba2b1eef35e4 100644 (file)
   Produces the data needed to calculate the quality assurance. 
   All data must be mergeable objects.
   P. Christiansen, Lund, January 2008
-*/
 
-/*
-  Implementation:
+  Updated June 2010:
+  ==================
 
-  We have chosen to have the histograms as non-persistent meber to
-  allow better debugging. In the copy constructor we then have to
-  assign the pointers to the existing histograms in the copied
-  list. This have been implemented but not tested.
+  The "beautification" of the online DQM histograms have been moved to
+  an amore macro.  
+
+  The per event RAW histograms have been modified in AliTPCdataQA and
+  the copies have therefore also been modified here.
+
+  The AliTPCdataQA can now be configured a bit from here: time bin
+  range (extended default range to 1-1000, event range at start:
+  0-100000, 1000 events per bin). (At least the parameters are not
+  hardcoded:-)
+
+  Implementation:
+  ===============
 
   For the QA of the RAW data we use the class, AliTPCdataQA, from the
   existing TPC Calibration framework (which is more advanced than the
-  standard QA framework) and extract the histograms at the end. This
-  has been tested with zero-suppressed data. The Analyse method of the
-  AliTPCdataQA class is called in the method, EndOfDetectorCycle, and
-  there also: 1d histogram(s) are projected and added to the QA list.
-*/
-
-/*
-  TODO:
-  Sumw2 for RAW histogram(s)?
-  RecPoints and ESD could have many more histograms
+  standard QA framework) and extract the histograms at the end. The
+  Analyse method of the AliTPCdataQA class is called in the method,
+  EndOfDetectorCycle, and there also: 1d histogram(s) are projected
+  and added to the QA list.
 */
 
 #include "AliTPCQADataMakerRec.h"
@@ -53,6 +55,7 @@
 #include <TSystem.h>
 #include <TBox.h>
 #include <TLine.h>
+#include <TAxis.h>
 
 // --- Standard library ---
 
 #include "AliTPCclusterMI.h"
 #include "AliSimDigits.h"
 
+
 ClassImp(AliTPCQADataMakerRec)
 
 //____________________________________________________________________________ 
 AliTPCQADataMakerRec::AliTPCQADataMakerRec() : 
 AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC), 
                  "TPC Rec Quality Assurance Data Maker"),
-  fTPCdataQA(NULL),
-  fBeautifyOption(1),   // 0:no beautify, !=0:beautify RAW 
-  fOccHighLimit(1e-4),  // high limit for accepting occupancy values
-  fQmaxLowLimit(8),    // low limit for accepting Qmax values
-  fQmaxHighLimit(40)    // high limit for accepting Qmax values
+fTPCdataQA(NULL),
+fRawMaxEvents(100000),
+fRawEventsPerBin(1000),
+fRawFirstTimeBin(1),
+fRawLastTimeBin(1000)
 {
   // ctor
   fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
@@ -92,10 +96,10 @@ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC),
 AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
   AliQADataMakerRec(),
   fTPCdataQA(NULL),
-  fBeautifyOption(qadm.GetBeautifyOption()),
-  fOccHighLimit(qadm.GetOccHighLimit()),
-  fQmaxLowLimit(qadm.GetQmaxLowLimit()),
-  fQmaxHighLimit(qadm.GetQmaxHighLimit())
+  fRawMaxEvents(qadm.GetRawMaxEvents()),
+  fRawEventsPerBin(qadm.GetRawEventsPerBin()),
+  fRawFirstTimeBin(qadm.GetRawFirstTimeBin()),
+  fRawLastTimeBin(qadm.GetRawLastTimeBin())
 {
   //copy ctor 
   // Does not copy the calibration object, instead InitRaws have to be
@@ -228,9 +232,23 @@ void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArr
         } // end loop over sectors
       
        // update event histograms - copy info from TPDdataQA histos
-       TH1F* hQAOccVsEvent = fTPCdataQA[specie]->GetHistOccupancyVsEvent();
-       TH1F* hQANclVsEvent = fTPCdataQA[specie]->GetHistNclustersVsEvent();
+       const TH1F* hQAOccVsEvent = fTPCdataQA[specie]->GetHistOccupancyVsEvent();
+       const TH1F* hQANclVsEvent = fTPCdataQA[specie]->GetHistNclustersVsEvent();
        
+       // In case the histogram limits have changed we have to update
+       // them here
+       if(histRawsOccupancy->GetXaxis()->GetXmax()!=
+          hQAOccVsEvent->GetXaxis()->GetXmax()) {
+         
+         histRawsOccupancyVsEvent->GetXaxis()->Set(histRawsOccupancyVsEvent->GetXaxis()->GetNbins(), hQAOccVsEvent->GetXaxis()->GetXmin(), hQAOccVsEvent->GetXaxis()->GetXmax()); 
+         
+         histRawsNclustersVsEvent->GetXaxis()->Set(histRawsOccupancyVsEvent->GetXaxis()->GetNbins(), hQANclVsEvent->GetXaxis()->GetXmin(), hQANclVsEvent->GetXaxis()->GetXmax()); 
+       }
+       
+       // reset the number of entries
+       histRawsOccupancyVsEvent->SetEntries(0);
+       histRawsNclustersVsEvent->SetEntries(0);
+
        // the two event histograms should have the same number of bins
        const Int_t nBins = hQAOccVsEvent->GetXaxis()->GetNbins();
        for(Int_t bin = 1; bin <= nBins; bin++) {
@@ -239,9 +257,6 @@ void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArr
          histRawsNclustersVsEvent->SetBinContent(bin, hQANclVsEvent->GetBinContent(bin));
        }
        
-       histRawsOccupancyVsEvent->GetXaxis()->SetRange(hQAOccVsEvent->GetXaxis()->GetFirst(), hQAOccVsEvent->GetXaxis()->GetLast());
-       histRawsNclustersVsEvent->GetXaxis()->SetRange(hQANclVsEvent->GetXaxis()->GetFirst(), hQANclVsEvent->GetXaxis()->GetLast());
-
         // Normalize histograms
         histRawsOccupancyVsSector->Divide(hNormOcc);
         histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter));
@@ -249,107 +264,7 @@ void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArr
         histRawsQmaxVsSector->Divide(hNormNclusters);
         delete hNormOcc;
         delete hNormNclusters;
-
-       if(fBeautifyOption!=0) {
-         // Help make the histogram easier to interpret for the DQM shifter
-         
-         histRawsOccupancyVsSector->ResetBit(AliQAv1::GetQABit());
-         histRawsQmaxVsSector->ResetBit(AliQAv1::GetQABit());
-
-         histRawsOccupancyVsSector->SetMinimum(0.0);
-         if(histRawsOccupancyVsSector->GetMaximum()<1.5*fOccHighLimit)
-           histRawsOccupancyVsSector->SetMaximum(1.5*fOccHighLimit);
-         
-         histRawsQmaxVsSector->SetMinimum(0.0);
-         if(histRawsQmaxVsSector->GetMaximum()<1.5*fQmaxHighLimit)
-           histRawsQmaxVsSector->SetMaximum(1.5*fQmaxHighLimit);
-         
-         Double_t xminOcc = histRawsOccupancyVsSector->GetXaxis()->GetXmin();
-         Double_t xmaxOcc = histRawsOccupancyVsSector->GetXaxis()->GetXmax();
-         Double_t yminOcc = histRawsOccupancyVsSector->GetMinimum();
-         Double_t ymaxOcc = histRawsOccupancyVsSector->GetMaximum();
-         
-         Double_t xminQmax = histRawsQmaxVsSector->GetXaxis()->GetXmin();
-         Double_t xmaxQmax = histRawsQmaxVsSector->GetXaxis()->GetXmax();
-//       Double_t yminQmax = histRawsQmaxVsSector->GetMinimum();
-//       Double_t ymaxQmax = histRawsQmaxVsSector->GetMaximum();
-         
-         // For reasons not understood the following stopped working
-         // in the DQM and instead lines were adopted:
-//       TBox* boxOccOk = new TBox(xminOcc,0,xmaxOcc,fOccHighLimit);
-//       boxOccOk->SetFillColor(kGreen);
-//       histRawsOccupancyVsSector->GetListOfFunctions()->Add(boxOccOk);
-
-         TLine* lineOccMin = new TLine(xminOcc,0,xmaxOcc,0);
-         lineOccMin->SetLineColor(kGreen);
-         lineOccMin->SetLineWidth(2);
-         histRawsOccupancyVsSector->GetListOfFunctions()->Add(lineOccMin);
-
-         TLine* lineOccMax = new TLine(xminOcc,fOccHighLimit, xmaxOcc,fOccHighLimit);
-         lineOccMax->SetLineColor(kGreen);
-         lineOccMax->SetLineWidth(2);
-         histRawsOccupancyVsSector->GetListOfFunctions()->Add(lineOccMax);
-
-         // For some reason this dtopped working
-//       TBox* boxQmaxOk = new TBox(xminQmax,fQmaxLowLimit,xmaxQmax,fQmaxHighLimit);
-//       boxQmaxOk->SetFillColor(kGreen);
-//       histRawsQmaxVsSector->GetListOfFunctions()->Add(boxQmaxOk);
-
-         TLine* lineQmaxMin = new TLine(xminQmax,fQmaxLowLimit, xmaxQmax,fQmaxLowLimit);
-         lineQmaxMin->SetLineColor(kGreen);
-         lineQmaxMin->SetLineWidth(2);
-         histRawsQmaxVsSector->GetListOfFunctions()->Add(lineQmaxMin);
-
-         TLine* lineQmaxMax = new TLine(xminQmax,fQmaxHighLimit, xmaxQmax,fQmaxHighLimit);
-         lineQmaxMax->SetLineColor(kGreen);
-         lineQmaxMax->SetLineWidth(2);
-         histRawsQmaxVsSector->GetListOfFunctions()->Add(lineQmaxMax);
-         
-         
-         for(Int_t bin = 1; bin <= 72; bin++) {
-           
-           if(histRawsOccupancyVsSector->GetBinContent(bin)<=0 ||
-              histRawsOccupancyVsSector->GetBinContent(bin)>fOccHighLimit) {
-             
-             histRawsOccupancyVsSector->SetBit(AliQAv1::GetQABit());
-
-             TBox* boxErr = 
-               new TBox(histRawsOccupancyVsSector->GetXaxis()->GetBinLowEdge(bin), yminOcc,
-                        histRawsOccupancyVsSector->GetXaxis()->GetBinUpEdge(bin), ymaxOcc);
-             boxErr->SetFillColor(kRed);
-             //              histRawsOccupancyVsSector->GetListOfFunctions()->Add(boxErr);
-           }
-           
-           if(histRawsQmaxVsSector->GetBinContent(bin)<fQmaxLowLimit||
-              histRawsQmaxVsSector->GetBinContent(bin)>fQmaxHighLimit) {
-             
-             // Mark that histogram has error
-             histRawsQmaxVsSector->SetBit(AliQAv1::GetQABit());
-
-         // For reasons not understood the following stopped working
-         // in the DQM and instead lines were adopted:
-//           TBox* boxErr = 
-//             new TBox(histRawsQmaxVsSector->GetXaxis()->GetBinLowEdge(bin), yminQmax,
-//                      histRawsQmaxVsSector->GetXaxis()->GetBinUpEdge(bin), ymaxQmax);
-//           boxErr->SetFillColor(kRed);
-             //              histRawsQmaxVsSector->GetListOfFunctions()->Add(boxErr);
-           }
-         }
-
-         // For reasons not understood the following stopped working
-         // in the DQM and instead lines were adopted:
-         // Now we have to add a copy of the histograms to draw
-         // because the boxes covers the data points
-//       TH1F* hOccCopy = new TH1F(*histRawsOccupancyVsSector);
-//       hOccCopy->SetOption("SAME P");
-//       histRawsOccupancyVsSector->GetListOfFunctions()->Add(hOccCopy);
-
-//       TH1F* hQmaxCopy = new TH1F(*histRawsQmaxVsSector);
-//       hQmaxCopy->SetOption("SAME P");
-//       histRawsQmaxVsSector->GetListOfFunctions()->Add(hQmaxCopy);
-
-       } // end beautify
+       
       }
     }
   }
@@ -381,9 +296,6 @@ void AliTPCQADataMakerRec::InitESDs()
             50, 0, 5);
   histESDpt->Sumw2();
   Add2ESDsList(histESDpt, kPt, !expert, image);
-
-  // This means we are not running DQM so do not beautify
-  SetBeautifyOption(0);
 }
 
 //____________________________________________________________________________ 
@@ -407,10 +319,14 @@ void AliTPCQADataMakerRec::InitRaws()
     // we create all dataQAs at the first call to this method
     if(fTPCdataQA[specie]!=0) // data QA already created
       continue;
-    fTPCdataQA[specie] = new AliTPCdataQA(AliRecoParam::ConvertIndex(specie));
+
+    fTPCdataQA[specie] = 
+      new AliTPCdataQA(AliRecoParam::ConvertIndex(specie));
     LoadMaps(); // Load Altro maps
     fTPCdataQA[specie]->SetAltroMapping(fMapping); // set Altro mapping
-    fTPCdataQA[specie]->SetRangeTime(100, 920); // set time bin interval 
+    fTPCdataQA[specie]->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval 
+    fTPCdataQA[specie]->SetMaxEvents(fRawMaxEvents);
+    fTPCdataQA[specie]->SetEventsPerBin(fRawEventsPerBin);
 //    Add2RawsList(fTPCdataQA, kTPCdataQ, !expert, image, !saveCorrA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
   }
 
@@ -451,29 +367,15 @@ void AliTPCQADataMakerRec::InitRaws()
   Add2RawsList(histRawsQmaxVsSector, kRawsQmaxVsSector, !expert, image, !saveCorr);
 
   // Get histogram information from data QA to build copy
-  TH1F* hOccHelp = fTPCdataQA[0]->GetHistOccupancyVsEvent();
+  const TH1F* hOccHelp = fTPCdataQA[0]->GetHistOccupancyVsEvent();
   TH1F * histRawsOccupancyVsEvent = 
-    new TH1F("hRawsOccupancyVsEvent", hOccHelp->GetTitle(),
-            hOccHelp->GetXaxis()->GetNbins(),
-            hOccHelp->GetXaxis()->GetXmin(), hOccHelp->GetXaxis()->GetXmax());
-  histRawsOccupancyVsEvent->GetXaxis()->SetTitle(hOccHelp->GetXaxis()->GetTitle());
-  histRawsOccupancyVsEvent->GetYaxis()->SetTitle(hOccHelp->GetYaxis()->GetTitle());
-  histRawsOccupancyVsEvent->SetMarkerStyle(20);
-  histRawsOccupancyVsEvent->SetOption("P");
-  histRawsOccupancyVsEvent->SetStats(kFALSE);
+    CreateEventsHistCopy(hOccHelp, "hRawsOccupancyVsEvent");
   Add2RawsList(histRawsOccupancyVsEvent, kRawsOccupancyVsEvent, !expert, image, !saveCorr);
-
+  
   // Get histogram information from data QA to build copy
-  TH1F* hNclHelp = fTPCdataQA[0]->GetHistNclustersVsEvent();
+  const TH1F* hNclHelp = fTPCdataQA[0]->GetHistNclustersVsEvent();
   TH1F * histRawsNclustersVsEvent = 
-    new TH1F("hRawsNclustersVsEvent", hNclHelp->GetTitle(),
-            hNclHelp->GetXaxis()->GetNbins(),
-            hNclHelp->GetXaxis()->GetXmin(), hNclHelp->GetXaxis()->GetXmax());
-  histRawsNclustersVsEvent->GetXaxis()->SetTitle(hNclHelp->GetXaxis()->GetTitle());
-  histRawsNclustersVsEvent->GetYaxis()->SetTitle(hNclHelp->GetYaxis()->GetTitle());
-  histRawsNclustersVsEvent->SetMarkerStyle(20);
-  histRawsNclustersVsEvent->SetOption("P");
-  histRawsNclustersVsEvent->SetStats(kFALSE);
+    CreateEventsHistCopy(hNclHelp, "hRawsNclustersVsEvent");
   Add2RawsList(histRawsNclustersVsEvent, kRawsNclustersVsEvent, !expert, image, !saveCorr);
 }
 
@@ -487,9 +389,6 @@ void AliTPCQADataMakerRec::InitDigits()
              1000, 0, 1000);
   histDigitsADC->Sumw2();
   Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
-
-  // This means we are not running DQM so do not beautify
-  SetBeautifyOption(0);
 }
 
 //____________________________________________________________________________ 
@@ -539,9 +438,6 @@ void AliTPCQADataMakerRec::InitRecPoints()
             159, 0, 159);
   histRecPointsRow->Sumw2();
   Add2RecPointsList(histRecPointsRow, kRow, !expert, image);
-
-  // This means we are not running DQM so do not beautify
-  SetBeautifyOption(0);
 }
 
 //____________________________________________________________________________
@@ -698,8 +594,6 @@ void AliTPCQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
        Int_t  lastTime     = fTPCdataQA[specie]->GetLastTimeBin();
        Int_t  minADC       = fTPCdataQA[specie]->GetAdcMin();
        Int_t  maxADC       = fTPCdataQA[specie]->GetAdcMax();
-       Int_t  maxEvents    = fTPCdataQA[specie]->GetMaxEvents();
-       Int_t  eventsPerBin = fTPCdataQA[specie]->GetEventsPerBin();
 
        //delete old
        delete fTPCdataQA[specie]; 
@@ -711,9 +605,30 @@ void AliTPCQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
        fTPCdataQA[specie]->SetAltroMapping(fMapping);
        fTPCdataQA[specie]->SetRangeTime(firstTime, lastTime);
        fTPCdataQA[specie]->SetRangeAdc(minADC, maxADC);
-       fTPCdataQA[specie]->SetMaxEvents(maxEvents);
-       fTPCdataQA[specie]->SetEventsPerBin(eventsPerBin);
+       // Here we want to restore the default configuration because
+       // the max events and events are adjusted for the last run
+       fTPCdataQA[specie]->SetMaxEvents(fRawMaxEvents);
+       fTPCdataQA[specie]->SetEventsPerBin(fRawEventsPerBin);
       }
     }
   }
 }
+
+//____________________________________________________________________________
+TH1F* AliTPCQADataMakerRec::CreateEventsHistCopy(const TH1F* hist, 
+                                                const Char_t* copyName)
+{
+  // This method is used to create a copy of the event histograms
+  
+  TH1F* histCopy = new TH1F(copyName, hist->GetTitle(),
+                           hist->GetXaxis()->GetNbins(),
+                           hist->GetXaxis()->GetXmin(), 
+                           hist->GetXaxis()->GetXmax());
+  histCopy->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
+  histCopy->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
+  histCopy->SetMarkerStyle(20);
+  histCopy->SetOption("P");
+  histCopy->SetStats(kFALSE);
+
+  return histCopy;
+}
index 11058aa8a1a14e9f25aaaa621152ee9f6f68eedd..e3b76f8f4a0cd7b6a80d69c9bb86402d49da0cc4 100644 (file)
@@ -39,17 +39,16 @@ public:
   AliTPCQADataMakerRec& operator = (const AliTPCQADataMakerRec& qadm) ;
   virtual ~AliTPCQADataMakerRec(); 
   
-  void SetBeautifyOption(Int_t value)  {fBeautifyOption= value;}
-  void SetOccHighLimit(Float_t value)  {fOccHighLimit  = value;}
-  void SetQmaxLowLimit(Float_t value)  {fQmaxLowLimit  = value;}
-  void SetQmaxHighLimit(Float_t value) {fQmaxHighLimit = value;}
+  virtual void ResetDetector(AliQAv1::TASKINDEX_t task);
 
-  Int_t   GetBeautifyOption() const {return fBeautifyOption;}
-  Float_t GetOccHighLimit() const {return fOccHighLimit; }
-  Float_t GetQmaxLowLimit() const {return fQmaxLowLimit; }
-  Float_t GetQmaxHighLimit() const {return fQmaxHighLimit;}
+  Int_t  GetRawMaxEvents()      const { return fRawMaxEvents;     }
+  Int_t  GetRawEventsPerBin()   const { return fRawEventsPerBin;  }
+  Int_t  GetRawFirstTimeBin() const { return fRawFirstTimeBin; }
+  Int_t  GetRawLastTimeBin()  const { return fRawLastTimeBin;  }
 
-  virtual void ResetDetector(AliQAv1::TASKINDEX_t task);
+  void  SetRawMaxEvents   (Int_t value) { fRawMaxEvents = value; }
+  void  SetRawEventsPerBin(Int_t value) { fRawEventsPerBin = value; }
+  void  SetRawRangeTime(Int_t tMin, Int_t tMax){ fRawFirstTimeBin=tMin; fRawLastTimeBin=tMax;}
 
 private:
   virtual void   StartOfDetectorCycle() {}; // empty 
@@ -74,14 +73,16 @@ private:
   
   virtual void LoadMaps();
 
+  TH1F* CreateEventsHistCopy(const TH1F* hist, const Char_t* copyName);
+
   AliTPCAltroMapping *fMapping[6]; //! Pointers to ALTRO mapping
   AliTPCdataQA** fTPCdataQA;//! TPC calibration object for making raw data QA
 
-  Int_t   fBeautifyOption;//! 0:no beautify, !=0:beautify RAW 
-  Float_t fOccHighLimit;  //! high limit for accepting occupancy values
-  Float_t fQmaxLowLimit;  //! low limit for accepting Qmax values
-  Float_t fQmaxHighLimit; //! high limit for accepting Qmax values
-  
+  Int_t fRawMaxEvents;      //! Max events for RAW QA event histograms
+  Int_t fRawEventsPerBin;   //! Events per bin for RAW QA event histograms
+  Int_t fRawFirstTimeBin;   //! First Time bin needed for RAW QA
+  Int_t fRawLastTimeBin;    //! Last Time bin needed for RAW QA
+
   ClassDef(AliTPCQADataMakerRec,1)  // TPC Rec Quality Assurance Data Maker 
 };
 
index b9bd5e430f1d6c5f508f474d487a047b5a46a710..2cefe6129896e7f4fcc1ae3f7d79d3771009d561 100644 (file)
 /* $Id$ */
 
 /*
+  June 2010
+
+  This update should solve two problems mainly:
+  * The vs event histograms have been limited to a fixed size for the
+  DQM. The 500k seemed to be a big size but is no longer so, so we
+  need to dynamically expand the range. The non-trivial point is that
+  we also have to do it for the copy owned by AliTPCQADataMakerRec.
+  * The amoreGui now remembers the x-range of the first visualization so
+  the trick of setting the relevant event range as the histogram is
+  filled no longer works.
+
+  The fix is a bit crude but avoids creating a new histogram. Instead
+  the range is expanded (max events and events per bin is doubled) but
+  the number of bins is kept constant! In this way we can change just
+  double the max of the X-axis of the hist and rebin the data. The
+  same can easily be done for the copy owned by AliTPCQADataMakerRec.
+
+  CAUTION:
+  If we change the number of bins we could crash the whole system
+  because ROOT does not create space for extra bins! (but we do not do
+  this). In that way it is a crude solution.
+  The rebinning in the code only works for an even number of bins.
+
+  In addition to the above a bug in the reading of the config file was
+  also found and corrected. fAdcMax was set instead of fEventsPerBin.
+
+  Finally cout was changes to AliInfo.
+
   February 2008
 
   The code has been heavily modified so that now the RAW data is
 */
 
 
-// stl includes
-#include <iostream>
-
-using namespace std;
-
 //Root includes
 #include <TH1F.h>
 #include <TH2F.h>
@@ -314,7 +337,7 @@ AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
   if (config->GetValue("AdcMin"))       fAdcMin = ((TObjString*)config->GetValue("AdcMin"))->GetString().Atoi();
   if (config->GetValue("AdcMax"))       fAdcMax = ((TObjString*)config->GetValue("AdcMax"))->GetString().Atoi();
   if (config->GetValue("MaxEvents"))    fMaxEvents = ((TObjString*)config->GetValue("MaxEvents"))->GetString().Atoi();
-  if (config->GetValue("EventsPerBin")) fAdcMax = ((TObjString*)config->GetValue("EventsPerBin"))->GetString().Atoi();
+  if (config->GetValue("EventsPerBin")) fEventsPerBin = ((TObjString*)config->GetValue("EventsPerBin"))->GetString().Atoi();
 }
 
 //_____________________________________________________________________
@@ -381,7 +404,6 @@ TH1F* AliTPCdataQA::GetHistOccupancyVsEvent()
     Int_t nBins = fMaxEvents/fEventsPerBin;
     fHistOccupancyVsEvent = new TH1F("hOccupancyVsEvent", "Occupancy vs event number (~time); Event number; Occupancy", nBins, 0, nBins*fEventsPerBin);
     fHistOccupancyVsEvent->SetDirectory(0);
-    fHistOccupancyVsEvent->GetXaxis()->SetRange(0, 10);
   }
   
   return fHistOccupancyVsEvent;
@@ -401,7 +423,6 @@ TH1F* AliTPCdataQA::GetHistNclustersVsEvent()
     Int_t nBins = fMaxEvents/fEventsPerBin;
     fHistNclustersVsEvent = new TH1F("hNclustersVsEvent", "Nclusters vs event number (~time); Event number; Nclusters per event", nBins, 0, nBins*fEventsPerBin);
     fHistNclustersVsEvent->SetDirectory(0);
-    fHistNclustersVsEvent->GetXaxis()->SetRange(0, 10);
   }
   
   return fHistNclustersVsEvent;
@@ -418,43 +439,60 @@ void AliTPCdataQA::UpdateEventHistograms()
   if (!fHistNclustersVsEvent)
     GetHistNclustersVsEvent();
   
+  if(fEventCounter > fMaxEvents) {
+    
+    // we have to expand the histogram to handle the larger number of
+    // events. The way it is done now is to double the range and the
+    // number of events per bin (so the number of histogram bins stays
+    // constant)
+    fEventsPerBin *= 2;
+    fMaxEvents *= 2;
+
+    // Change histogram limits
+    const Int_t nBins = fHistOccupancyVsEvent->GetXaxis()->GetNbins();
+    fHistOccupancyVsEvent->GetXaxis()->Set(nBins, fHistOccupancyVsEvent->GetXaxis()->GetNbins(), fMaxEvents);
+    fHistNclustersVsEvent->GetXaxis()->Set(nBins, fHistNclustersVsEvent->GetXaxis()->GetNbins(), fMaxEvents);
+
+    // Rebin the histogram
+    for(Int_t bin = 1; bin <= nBins; bin+=2) {
+
+      Int_t newBin = TMath::Nint(Float_t(bin+1)/2.0);
+      Float_t newContent = (fHistOccupancyVsEvent->GetBinContent(bin)+
+                           fHistOccupancyVsEvent->GetBinContent(bin+1))/2.0;
+      fHistOccupancyVsEvent->SetBinContent(newBin, newContent); 
+
+      newContent = (fHistNclustersVsEvent->GetBinContent(bin)+
+                   fHistNclustersVsEvent->GetBinContent(bin+1))/2.0;
+      fHistNclustersVsEvent->SetBinContent(newBin, newContent); 
+    }
+
+    // Set the remaining bins to 0
+    Int_t lastHalf = nBins/2 +1;
+    for(Int_t bin = lastHalf; bin <= nBins; bin++) {
+
+      fHistOccupancyVsEvent->SetBinContent(bin, 0); 
+      fHistNclustersVsEvent->SetBinContent(bin, 0); 
+    }
+
+    // In this case we should nut update but wait untill the new
+    // number of events per bin is reached!
+    return;
+  }
+
+  const Int_t bin = TMath::Nint(Float_t(fEventCounter)/fEventsPerBin);
+
   Float_t averageOccupancy =
     Float_t(fSignalCounter)/fEventsPerBin/(fLastTimeBin - fFirstTimeBin +1.0)
-    / 570132; // 570,132 is number of pads
-  if(fEventCounter<=fMaxEvents) 
-    UpdateEventHisto(fHistOccupancyVsEvent, averageOccupancy);
+    / 570132.0; // 570,132 is number of pads
+  fHistOccupancyVsEvent->SetBinContent(bin, averageOccupancy);
   fSignalCounter = 0;
   
   Float_t averageNclusters =
     Float_t(fClusterCounter)/fEventsPerBin;
-  if(fEventCounter<=fMaxEvents) 
-    UpdateEventHisto(fHistNclustersVsEvent, averageNclusters);
+  fHistNclustersVsEvent->SetBinContent(bin, averageNclusters);
   fClusterCounter = 0;
 }
 
-//_____________________________________________________________________
-void AliTPCdataQA::UpdateEventHisto(TH1F* hist, Float_t average)
-{
-  // Do the actually updating of each histogram and 
-  // change the visible range if needed
-  
-  // in case someone would have overwritten the value here
-  // (not so pretty  but OK for this I think)
-  fEventsPerBin = hist->GetXaxis()->GetBinWidth(1);
-  Int_t bin = TMath::Nint(Float_t(fEventCounter)/fEventsPerBin);
-  
-  if (hist->GetBinContent(bin)>0) { 
-    AliError("Bin already filled. This should not happen.");
-  } else {
-    hist->SetBinContent(bin, average);
-  }
-  
-  // expand the visible range of the histogram if needed
-  if(hist->GetXaxis()->GetLast()<= bin) {
-    hist->GetXaxis()->SetRange(0, Int_t(1.3*bin));
-  }
-}
-
 //_____________________________________________________________________
 Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
 {
@@ -466,7 +504,9 @@ Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
   Int_t lastSector = -1;
   
   while ( rawStreamV3->NextDDL() ){
+
     while ( rawStreamV3->NextChannel() ){
+    
       Int_t iSector = rawStreamV3->GetSector(); //  current sector
       Int_t iRow    = rawStreamV3->GetRow();    //  current row
       Int_t iPad    = rawStreamV3->GetPad();    //  current pad
@@ -483,6 +523,7 @@ Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
       }
       
       while ( rawStreamV3->NextBunch() ){
+
         Int_t  startTbin    = (Int_t)rawStreamV3->GetStartTimeBin();
         Int_t  bunchlength  = (Int_t)rawStreamV3->GetBunchLength();
         const UShort_t *sig = rawStreamV3->GetSignals();
@@ -495,8 +536,8 @@ Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
       }
     }
   }
-  
-  if (lastSector>=0&&nSignals>0)
+    
+  if (lastSector>=0&&nSignals>0)  
     FindLocalMaxima(lastSector);
   
   return withInput;
@@ -513,7 +554,7 @@ Bool_t AliTPCdataQA::ProcessEvent(AliRawReader *const rawReader)
   if(res) {
     fEventCounter++; // only increment event counter if there is TPC data
 
-    if(fEventCounter%fEventsPerBin==0)
+    if(fEventCounter%fEventsPerBin==0) 
       UpdateEventHistograms();
   }
   return res;
@@ -936,7 +977,6 @@ void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
     } // end loop over signals
   } // end loop over rows
   
-  //  cout << "Number of local maximas found: " << nLocalMaxima << endl;
   fClusterCounter += nLocalMaxima;
 }
 
@@ -947,23 +987,22 @@ void AliTPCdataQA::Analyse()
   //  Calculate calibration constants
   //
   
-  cout << "Analyse called" << endl;
+  AliInfo("Analyse called");
 
   if(fIsAnalysed == kTRUE) {
     
-    cout << "No new data since Analyse was called last time" << endl;
+    AliInfo("No new data since Analyse was called last time");
     return;
   }
 
   if(fEventCounter==0) {
     
-    cout << "EventCounter == 0, Cannot analyse" << endl;
+      AliInfo("EventCounter == 0, Cannot analyse");
     return;
   }
   
   Int_t nTimeBins = fLastTimeBin - fFirstTimeBin +1;
-  cout << "EventCounter: " << fEventCounter << endl
-       << "TimeBins: " << nTimeBins << endl;
+  AliInfo(Form("EventCounter: %d , TimeBins: %d", fEventCounter, nTimeBins));
 
   Float_t normalization = 1.0 / Float_t(fEventCounter * nTimeBins);
   fNoThreshold->Multiply(normalization);  
index a4e9365b132a4251121f98f482c345fbb5f7d60c..866a1e0a53f2ef301696ea8ae5f4887f64cd90f5 100644 (file)
@@ -105,7 +105,6 @@ private:
               const Int_t pad, const Int_t maxTimeBins, 
               Int_t& timeMin,Int_t& timeMax,Int_t& padMin,Int_t& padMax) const;
   void UpdateEventHistograms();
-  void UpdateEventHisto(TH1F* hist, Float_t average);
 
   Int_t fFirstTimeBin;              //  First Time bin needed for analysis
   Int_t fLastTimeBin;               //  Last Time bin needed for analysis