EMCAL/AliCaloCalibPedestal.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 //* $Id$ */
  16
  17 //________________________________________________________________________
  18 //
  19 // A help class for monitoring and calibration tools: MOOD, AMORE etc.,
  20 // It can be created and used a la (ctor):
  21 /*
  22   //Create the object for making the histograms
  23   fPedestals = new AliCaloCalibPedestal( fDetType );
  24   // AliCaloCalibPedestal knows how many modules we have for PHOS or EMCAL
  25   fNumModules = fPedestals->GetModules();
  26 */
  27 // fed an event:
  28 //  fPedestals->ProcessEvent(fCaloRawStream);
  29 // asked to draw histograms:
  30 //  fPedestals->GetDeadMap(i)->Draw("col");
  31 // or
  32 //  fPedestals->GetPeakProfileHighGainRatio((i < fNumModules) ? i : fVisibleModule)->Draw("colz");
  33 // etc.
  34 // The pseudo-code examples above were from the first implementation in MOOD (summer 2007).
  35 //________________________________________________________________________
  36
  37 //#include "TCanvas.h"
  38 #include "TH1.h"
  39 #include "TF1.h"
  40 #include "TFile.h"
  41 #include <fstream>
  42 #include <sstream>
  43 #include <iostream>
  44 #include <stdexcept>
  45 #include <cmath>
  46
  47 #include "AliRawReader.h"
  48 #include "AliCaloRawStreamV3.h"
  49
  50 //The include file
  51 #include "AliCaloCalibPedestal.h"
  52
  53 ClassImp(AliCaloCalibPedestal)
  54
  55 using namespace std;
  56
  57 // ctor; initialize everything in order to avoid compiler warnings
  58 AliCaloCalibPedestal::AliCaloCalibPedestal(kDetType detectorType) :
  59   TObject(),
  60   fPedestalLowGain(),
  61   fPedestalHighGain(),
  62   fPedestalLEDRefLowGain(),
  63   fPedestalLEDRefHighGain(),
  64   fPeakMinusPedLowGain(),
  65   fPeakMinusPedHighGain(),
  66   fPeakMinusPedHighGainHisto(),
  67   fPedestalLowGainDiff(),
  68   fPedestalHighGainDiff(),
  69   fPedestalLEDRefLowGainDiff(),
  70   fPedestalLEDRefHighGainDiff(),
  71   fPeakMinusPedLowGainDiff(),
  72   fPeakMinusPedHighGainDiff(),
  73   fPedestalLowGainRatio(),
  74   fPedestalHighGainRatio(),
  75   fPedestalLEDRefLowGainRatio(),
  76   fPedestalLEDRefHighGainRatio(),
  77   fPeakMinusPedLowGainRatio(),
  78   fPeakMinusPedHighGainRatio(),
  79   fDeadMap(),
  80   fNEvents(0),
  81   fNChanFills(0),
  82   fDeadTowers(0),
  83   fNewDeadTowers(0),
  84   fResurrectedTowers(0),
  85   fReference(0),
  86   fDetType(kNone),
  87   fColumns(0),
  88   fRows(0),
  89   fLEDRefs(0),
  90   fModules(0),
  91   fRowMin(0),
  92   fRowMax(0),
  93   fRowMultiplier(0),
  94   fCaloString(),
  95   fMapping(NULL),
  96   fRunNumber(-1),
  97   fSelectPedestalSamples(kTRUE),
  98   fFirstPedestalSample(0),
  99   fLastPedestalSample(15),
 100   fDeadThreshold(5),
 101   fWarningThreshold(50),
 102   fWarningFraction(0.002),
 103   fHotSigma(5)
 104 {
 105   //Default constructor. First we set the detector-type related constants.
 106   if (detectorType == kPhos) {
 107     fColumns = fgkPhosCols;
 108     fRows = fgkPhosRows;
 109     fLEDRefs = fgkPhosLEDRefs;
 110     fModules = fgkPhosModules;
 111     fCaloString = "PHOS";
 112     fRowMin = -1*fRows;
 113     fRowMax = 0;
 114     fRowMultiplier = -1;
 115   }
 116   else {
 117     //We'll just trust the enum to keep everything in line, so that if detectorType
 118     //isn't kPhos then it is kEmCal. Note, however, that this is not necessarily the
 119     //case, if someone intentionally gives another number
 120     fColumns = AliEMCALGeoParams::fgkEMCALCols;
 121     fRows = AliEMCALGeoParams::fgkEMCALRows;
 122     fLEDRefs = AliEMCALGeoParams::fgkEMCALLEDRefs;
 123     fModules = AliEMCALGeoParams::fgkEMCALModules;
 124     fCaloString = "EMCAL";
 125     fRowMin = 0;
 126     fRowMax = fRows;
 127     fRowMultiplier = 1;
 128   }
 129   fDetType = detectorType;
 130
 131   // ValidateProfiles(); // not to be done in ctor; info from Axel N.
 132 }
 133
 134 //_____________________________________________________________________
 135 void AliCaloCalibPedestal::ValidateProfiles()
 136 {
 137   //Make sure the basic histos exist
 138   if (!fPedestalLowGain.IsEmpty()) return; //The profiles already exist. We just check one, because they're all created at
 139   //the same time
 140
 141   //Then, loop for the requested number of modules
 142   TString title, name;
 143   for (int i = 0; i < fModules; i++) {
 144     //Pedestals, low gain
 145     name = "hPedlowgain";
 146     name += i;
 147     title = "Pedestals, low gain, module ";
 148     title += i;
 149     fPedestalLowGain.Add(new TProfile2D(name, title,
 150                                         fColumns, 0.0, fColumns,
 151                                         fRows, fRowMin, fRowMax,"s"));
 152
 153     //Pedestals, high gain
 154     name = "hPedhighgain";
 155     name += i;
 156     title = "Pedestals, high gain, module ";
 157     title += i;
 158     fPedestalHighGain.Add(new TProfile2D(name, title,
 159                                          fColumns, 0.0, fColumns,
 160                                          fRows, fRowMin, fRowMax,"s"));
 161
 162     //LED Ref/Mon pedestals, low gain
 163     name = "hPedestalLEDReflowgain";
 164     name += i;
 165     title = "Pedestal LEDRef, low gain, module ";
 166     title += i;
 167     fPedestalLEDRefLowGain.Add(new TProfile(name, title,
 168                                             fLEDRefs, 0.0, fLEDRefs, "s"));
 169
 170     //LED Ref/Mon pedestals, high gain
 171     name = "hPedestalLEDRefhighgain";
 172     name += i;
 173     title = "Pedestal LEDRef, high gain, module ";
 174     title += i;
 175     fPedestalLEDRefHighGain.Add(new TProfile(name, title,
 176                                              fLEDRefs, 0.0, fLEDRefs, "s"));
 177
 178     //Peak-Pedestals, low gain
 179     name = "hPeakMinusPedlowgain";
 180     name += i;
 181     title = "Peak-Pedestal, low gain, module ";
 182     title += i;
 183     fPeakMinusPedLowGain.Add(new TProfile2D(name, title,
 184                                             fColumns, 0.0, fColumns,
 185                                             fRows, fRowMin, fRowMax,"s"));
 186
 187     //Peak-Pedestals, high gain
 188     name = "hPeakMinusPedhighgain";
 189     name += i;
 190     title = "Peak-Pedestal, high gain, module ";
 191     title += i;
 192     fPeakMinusPedHighGain.Add(new TProfile2D(name, title,
 193                                              fColumns, 0.0, fColumns,
 194                                              fRows, fRowMin, fRowMax,"s"));
 195
 196     //Peak-Pedestals, high gain - TH2F histo
 197     name = "hPeakMinusPedhighgainHisto";
 198     name += i;
 199     title = "Peak-Pedestal, high gain, module ";
 200     title += i;
 201     fPeakMinusPedHighGainHisto.Add(new TH2F(name, title,
 202                                             fColumns*fRows, 0.0, fColumns*fRows,
 203                                             100, 0, 1000));
 204
 205     name = "hDeadMap";
 206     name += i;
 207     title = "Dead map, module ";
 208     title += i;
 209     fDeadMap.Add(new TH2D(name, title, fColumns, 0.0, fColumns,
 210                           fRows, fRowMin, fRowMax));
 211
 212   }//end for nModules create the histograms
 213
 214   CompressAndSetOwner();
 215 }
 216
 217 //_____________________________________________________________________
 218 void AliCaloCalibPedestal::CompressAndSetOwner()
 219 {
 220   //Compress the arrays, in order to remove the empty objects (a 16 slot array is created by default)
 221   fPedestalLowGain.Compress();
 222   fPedestalHighGain.Compress();
 223   fPedestalLEDRefLowGain.Compress();
 224   fPedestalLEDRefHighGain.Compress();
 225   fPeakMinusPedLowGain.Compress();
 226   fPeakMinusPedHighGain.Compress();
 227   fPeakMinusPedHighGainHisto.Compress();
 228   fDeadMap.Compress();
 229
 230   // set owner ship for everyone
 231   fPedestalLowGain.SetOwner(kTRUE);
 232   fPedestalHighGain.SetOwner(kTRUE);
 233   fPedestalLEDRefLowGain.SetOwner(kTRUE);
 234   fPedestalLEDRefHighGain.SetOwner(kTRUE);
 235   fPeakMinusPedLowGain.SetOwner(kTRUE);
 236   fPeakMinusPedHighGain.SetOwner(kTRUE);
 237   fPeakMinusPedHighGainHisto.SetOwner(kTRUE);
 238   fPedestalLowGainDiff.SetOwner(kTRUE);
 239   fPedestalHighGainDiff.SetOwner(kTRUE);
 240   fPedestalLEDRefLowGainDiff.SetOwner(kTRUE);
 241   fPedestalLEDRefHighGainDiff.SetOwner(kTRUE);
 242   fPeakMinusPedLowGainDiff.SetOwner(kTRUE);
 243   fPeakMinusPedHighGainDiff.SetOwner(kTRUE);
 244   fPedestalLowGainRatio.SetOwner(kTRUE);
 245   fPedestalHighGainRatio.SetOwner(kTRUE);
 246   fPedestalLEDRefLowGainRatio.SetOwner(kTRUE);
 247   fPedestalLEDRefHighGainRatio.SetOwner(kTRUE);
 248   fPeakMinusPedLowGainRatio.SetOwner(kTRUE);
 249   fPeakMinusPedHighGainRatio.SetOwner(kTRUE);
 250   fDeadMap.SetOwner(kTRUE);
 251 }
 252
 253 // dtor
 254 //_____________________________________________________________________
 255 AliCaloCalibPedestal::~AliCaloCalibPedestal()
 256 {
 257   //dtor
 258
 259   if (fReference) delete fReference;//Delete the reference object, if it has been loaded
 260
 261   // delete also TObjArray's
 262   fPedestalLowGain.Delete();
 263   fPedestalHighGain.Delete();
 264   fPedestalLEDRefLowGain.Delete();
 265   fPedestalLEDRefHighGain.Delete();
 266   fPeakMinusPedLowGain.Delete();
 267   fPeakMinusPedHighGain.Delete();
 268   fPeakMinusPedHighGainHisto.Delete();
 269   fPedestalLowGainDiff.Delete();
 270   fPedestalHighGainDiff.Delete();
 271   fPedestalLEDRefLowGainDiff.Delete();
 272   fPedestalLEDRefHighGainDiff.Delete();
 273   fPeakMinusPedLowGainDiff.Delete();
 274   fPeakMinusPedHighGainDiff.Delete();
 275   fPedestalLowGainRatio.Delete();
 276   fPedestalHighGainRatio.Delete();
 277   fPedestalLEDRefLowGainRatio.Delete();
 278   fPedestalLEDRefHighGainRatio.Delete();
 279   fPeakMinusPedLowGainRatio.Delete();
 280   fPeakMinusPedHighGainRatio.Delete();
 281   fDeadMap.Delete();
 282
 283 }
 284
 285 // copy ctor
 286 //_____________________________________________________________________
 287 AliCaloCalibPedestal::AliCaloCalibPedestal(AliCaloCalibPedestal &ped) :
 288   TObject(ped),
 289   fPedestalLowGain(),
 290   fPedestalHighGain(),
 291   fPedestalLEDRefLowGain(),
 292   fPedestalLEDRefHighGain(),
 293   fPeakMinusPedLowGain(),
 294   fPeakMinusPedHighGain(),
 295   fPeakMinusPedHighGainHisto(),
 296   fPedestalLowGainDiff(),
 297   fPedestalHighGainDiff(),
 298   fPedestalLEDRefLowGainDiff(),
 299   fPedestalLEDRefHighGainDiff(),
 300   fPeakMinusPedLowGainDiff(),
 301   fPeakMinusPedHighGainDiff(),
 302   fPedestalLowGainRatio(),
 303   fPedestalHighGainRatio(),
 304   fPedestalLEDRefLowGainRatio(),
 305   fPedestalLEDRefHighGainRatio(),
 306   fPeakMinusPedLowGainRatio(),
 307   fPeakMinusPedHighGainRatio(),
 308   fDeadMap(),
 309   fNEvents(ped.GetNEvents()),
 310   fNChanFills(ped.GetNChanFills()),
 311   fDeadTowers(ped.GetDeadTowerCount()),
 312   fNewDeadTowers(ped.GetDeadTowerNew()),
 313   fResurrectedTowers(ped.GetDeadTowerResurrected()),
 314   fReference( 0 ), //! note that we do not try to copy the reference info here
 315   fDetType(ped.GetDetectorType()),
 316   fColumns(ped.GetColumns()),
 317   fRows(ped.GetRows()),
 318   fLEDRefs(ped.GetLEDRefs()),
 319   fModules(ped.GetModules()),
 320   fRowMin(ped.GetRowMin()),
 321   fRowMax(ped.GetRowMax()),
 322   fRowMultiplier(ped.GetRowMultiplier()),
 323   fCaloString(ped.GetCaloString()),
 324   fMapping(NULL), //! note that we are not copying the map info
 325   fRunNumber(ped.GetRunNumber()),
 326   fSelectPedestalSamples(ped.GetSelectPedestalSamples()),
 327   fFirstPedestalSample(ped.GetFirstPedestalSample()),
 328   fLastPedestalSample(ped.GetLastPedestalSample()),
 329   fDeadThreshold(ped.GetDeadThreshold()),
 330   fWarningThreshold(ped.GetWarningThreshold()),
 331   fWarningFraction(ped.GetWarningFraction()),
 332   fHotSigma(ped.GetHotSigma())
 333 {
 334   // Then the ObjArray ones; we add the histograms rather than trying TObjArray = assignment
 335   //DS: this has not really been tested yet..
 336   for (int i = 0; i < fModules; i++) {
 337     fPedestalLowGain.Add( ped.GetPedProfileLowGain(i) );
 338     fPedestalHighGain.Add( ped.GetPedProfileHighGain(i) );
 339     fPedestalLEDRefLowGain.Add( ped.GetPedLEDRefProfileLowGain(i) );
 340     fPedestalLEDRefHighGain.Add( ped.GetPedLEDRefProfileHighGain(i) );
 341     fPeakMinusPedLowGain.Add( ped.GetPeakProfileLowGain(i) );
 342     fPeakMinusPedHighGain.Add( ped.GetPeakProfileHighGain(i) );
 343     fPeakMinusPedHighGainHisto.Add( ped.GetPeakHighGainHisto(i) );
 344
 345     fDeadMap.Add( ped.GetDeadMap(i) );
 346   }//end for nModules
 347
 348   CompressAndSetOwner();
 349 }
 350
 351 // assignment operator; use copy ctor to make life easy..
 352 //_____________________________________________________________________
 353 AliCaloCalibPedestal& AliCaloCalibPedestal::operator = (AliCaloCalibPedestal &source)
 354 {
 355   // assignment operator; use copy ctor
 356   if (&source == this) return *this;
 357
 358   new (this) AliCaloCalibPedestal(source);
 359   return *this;
 360 }
 361
 362 //_____________________________________________________________________
 363 void AliCaloCalibPedestal::Reset()
 364 {
 365   ValidateProfiles(); // make sure histos/profiles exist
 366   // Reset all arrays/histograms
 367   for (int i = 0; i < fModules; i++) {
 368     GetPedProfileLowGain(i)->Reset();
 369     GetPedProfileHighGain(i)->Reset();
 370     GetPedLEDRefProfileLowGain(i)->Reset();
 371     GetPedLEDRefProfileHighGain(i)->Reset();
 372     GetPeakProfileLowGain(i)->Reset();
 373     GetPeakProfileHighGain(i)->Reset();
 374     GetPeakHighGainHisto(i)->Reset();
 375     GetDeadMap(i)->Reset();
 376
 377     if (!fPedestalLowGainDiff.IsEmpty()) {
 378       //This means that the comparison profiles have been created.
 379
 380       GetPedProfileLowGainDiff(i)->Reset();
 381       GetPedProfileHighGainDiff(i)->Reset();
 382       GetPedLEDRefProfileLowGainDiff(i)->Reset();
 383       GetPedLEDRefProfileHighGainDiff(i)->Reset();
 384       GetPeakProfileLowGainDiff(i)->Reset();
 385       GetPeakProfileHighGainDiff(i)->Reset();
 386
 387       GetPedProfileLowGainRatio(i)->Reset();
 388       GetPedProfileHighGainRatio(i)->Reset();
 389       GetPedLEDRefProfileLowGainRatio(i)->Reset();
 390       GetPedLEDRefProfileHighGainRatio(i)->Reset();
 391       GetPeakProfileLowGainRatio(i)->Reset();
 392       GetPeakProfileHighGainRatio(i)->Reset();
 393     }
 394   }
 395   fNEvents = 0;
 396   fNChanFills = 0;
 397   fDeadTowers = 0;
 398   fNewDeadTowers = 0;
 399   fResurrectedTowers = 0;
 400
 401   //To think about: should fReference be deleted too?... let's not do it this time, at least...
 402 }
 403
 404 // Parameter/cut handling
 405 //_____________________________________________________________________
 406 void AliCaloCalibPedestal::SetParametersFromFile(const char *parameterFile)
 407 {
 408   // Note: this method is a bit more complicated than it really has to be
 409   // - allowing for multiple entries per line, arbitrary order of the
 410   // different variables etc. But I wanted to try and do this in as
 411   // correct a C++ way as I could (as an exercise).
 412
 413   static const string delimitor("::");
 414
 415   // open, check input file
 416   ifstream in( parameterFile );
 417   if( !in ) {
 418     printf("in AliCaloCalibPedestal::SetParametersFromFile - Using default/run_time parameters.\n");
 419     return;
 420   }
 421
 422
 423   // read in
 424   char readline[1024];
 425   while ((in.rdstate() & ios::failbit) == 0 ) {
 426
 427     // Read into the raw char array and then construct a string
 428     // to do the searching
 429     in.getline(readline, 1024);
 430     istringstream s(readline);
 431
 432     while ( ( s.rdstate() & ios::failbit ) == 0 ) {
 433
 434       string keyValue;
 435       s >> keyValue;
 436
 437       // check stream status
 438       if( ( s.rdstate() & ios::failbit ) == ios::failbit) break;
 439
 440       // skip rest of line if comments found
 441       if( keyValue.substr( 0, 2 ) == "//" ) break;
 442
 443       // look for "::" in keyValue pair
 444       size_t position = keyValue.find( delimitor );
 445       if( position == string::npos ) {
 446         printf("wrong format for key::value pair: %s\n", keyValue.c_str());
 447       }
 448
 449       // split keyValue pair
 450       string key( keyValue.substr( 0, position ) );
 451       string value( keyValue.substr( position+delimitor.size(),
 452                                       keyValue.size()-delimitor.size() ) );
 453
 454       // check value does not contain a new delimitor
 455       if( value.find( delimitor ) != string::npos ) {
 456         printf("wrong format for key::value pair: %s\n", keyValue.c_str());
 457       }
 458
 459       // debug: check key value pair
 460       // printf("AliCaloCalibPedestal::SetParametersFromFile - key %s value %s\n", key.c_str(), value.c_str());
 461
 462       // if the key matches with something we expect, we assign the new value
 463       istringstream iss(value);
 464       // the comparison strings defined at the beginning of this method
 465       if ( (key == "fFirstPedestalSample") || (key == "fLastPedestalSample") || (key == "fDeadThreshold") || (key == "fWarningThreshold") || (key == "fWarningFraction") || (key == "fHotSigma") ) {
 466         printf("AliCaloCalibPedestal::SetParametersFromFile - key %s value %s\n", key.c_str(), value.c_str());
 467
 468         if (key == "fFirstPedestalSample") {
 469           iss >> fFirstPedestalSample;
 470         }
 471         else if (key == "fLastPedestalSample") {
 472           iss >> fLastPedestalSample;
 473         }
 474         else if (key == "fDeadThreshold") {
 475           iss >> fDeadThreshold;
 476         }
 477         else if (key == "fWarningThreshold") {
 478           iss >> fWarningThreshold;
 479         }
 480         else if (key == "fWarningFraction") {
 481           iss >> fWarningFraction;
 482         }
 483         else if (key == "fHotSigma") {
 484           iss >> fHotSigma;
 485         }
 486
 487       } // some match
 488
 489     }
 490   }
 491
 492   in.close();
 493   return;
 494
 495 }
 496
 497 //_____________________________________________________________________
 498 void AliCaloCalibPedestal::WriteParametersToFile(const char *parameterFile)
 499 {
 500   //Write parameters in file.
 501
 502   static const string delimitor("::");
 503   ofstream out( parameterFile );
 504   out << "// " << parameterFile << endl;
 505   out << "fFirstPedestalSample" << "::" << fFirstPedestalSample << endl;
 506   out << "fLastPedestalSample" << "::" << fLastPedestalSample << endl;
 507   out << "fDeadThreshold" << "::" << fDeadThreshold << endl;
 508   out << "fWarningThreshold" << "::" << fWarningThreshold << endl;
 509   out << "fWarningFraction" << "::" << fWarningFraction << endl;
 510   out << "fHotSigma" << "::" << fHotSigma << endl;
 511
 512   out.close();
 513   return;
 514 }
 515
 516 //_____________________________________________________________________
 517 Bool_t AliCaloCalibPedestal::AddInfo(AliCaloCalibPedestal *ped)
 518 {
 519   ValidateProfiles(); // make sure histos/profiles exist
 520   // just do this for the basic histograms/profiles that get filled in ProcessEvent
 521   // may not have data for all modules, but let's just Add everything..
 522   for (int i = 0; i < fModules; i++) {
 523     GetPedProfileLowGain(i)->Add( ped->GetPedProfileLowGain(i) );
 524     GetPedProfileHighGain(i)->Add( ped->GetPedProfileHighGain(i) );
 525     GetPedLEDRefProfileLowGain(i)->Add( ped->GetPedLEDRefProfileLowGain(i) );
 526     GetPedLEDRefProfileHighGain(i)->Add( ped->GetPedLEDRefProfileHighGain(i) );
 527     GetPeakProfileLowGain(i)->Add( ped->GetPeakProfileLowGain(i) );
 528     GetPeakProfileHighGain(i)->Add( ped->GetPeakProfileHighGain(i) );
 529     GetPeakHighGainHisto(i)->Add( ped->GetPeakHighGainHisto(i) );
 530
 531   }//end for nModules
 532
 533   // DeadMap; Diff profiles etc would need to be redone after this operation
 534
 535   return kTRUE;//We succesfully added info from the supplied object
 536 }
 537
 538 //_____________________________________________________________________
 539 Bool_t AliCaloCalibPedestal::ProcessEvent(AliRawReader *rawReader)
 540 {
 541   // if fMapping is NULL the rawstream will crate its own mapping
 542   AliCaloRawStreamV3 rawStream(rawReader, fCaloString, (AliAltroMapping**)fMapping);
 543   if (fDetType == kEmCal) {
 544     rawReader->Select("EMCAL", 0, AliEMCALGeoParams::fgkLastAltroDDL) ; //select EMCAL DDL range
 545   }
 546   return ProcessEvent(&rawStream);
 547 }
 548
 549 //_____________________________________________________________________
 550 Bool_t AliCaloCalibPedestal::ProcessEvent(AliCaloRawStreamV3 *in)
 551 {
 552   // Method to process=analyze one event in the data stream
 553   if (!in) return kFALSE; //Return right away if there's a null pointer
 554   in->Reset(); // just in case the next customer forgets to check if the stream was reset..
 555
 556   fNEvents++; // one more event
 557
 558   if (fNEvents==1) ValidateProfiles(); // 1st event, make sure histos/profiles exist
 559
 560   // indices for the reading
 561   int sample = 0;
 562   int time = 0;
 563   int i = 0; // sample counter
 564   int startBin = 0;
 565
 566   // start loop over input stream
 567   while (in->NextDDL()) {
 568     while (in->NextChannel()) {
 569
 570       // counters
 571       int max = AliEMCALGeoParams::fgkSampleMin, min = AliEMCALGeoParams::fgkSampleMax; // min and max sample values
 572       int nsamples = 0;
 573
 574       // pedestal samples
 575       int nPed = 0;
 576       vector<int> pedSamples;
 577
 578       while (in->NextBunch()) {
 579         const UShort_t *sig = in->GetSignals();
 580         startBin = in->GetStartTimeBin();
 581         nsamples += in->GetBunchLength();
 582         for (i = 0; i < in->GetBunchLength(); i++) {
 583           sample = sig[i];
 584           time = startBin--;
 585
 586           // check if it's a min or max value
 587           if (sample < min) min = sample;
 588           if (sample > max) max = sample;
 589
 590           // should we add it for the pedestal calculation?
 591           if ( (fFirstPedestalSample<=time && time<=fLastPedestalSample) || // sample time in range
 592                !fSelectPedestalSamples ) { // or we don't restrict the sample range.. - then we'll take all
 593             pedSamples.push_back( sig[i] );
 594             nPed++;
 595           }
 596
 597         } // loop over samples in bunch
 598       } // loop over bunches
 599
 600       if (nsamples > 0) { // this check is needed for when we have zero-supp. on, but not sparse readout
 601
 602       // it should be enough to check the SuperModule info for each DDL really, but let's keep it here for now
 603       int arrayPos = in->GetModule(); //The modules are numbered starting from 0
 604       if (arrayPos >= fModules) {
 605         //TODO: return an error message, if appopriate (perhaps if debug>0?)
 606         return kFALSE;
 607       }
 608       //Debug
 609       if (arrayPos < 0 || arrayPos >= fModules) {
 610         printf("Oh no: arrayPos = %i.\n", arrayPos);
 611       }
 612
 613       fNChanFills++; // one more channel found, and profile to be filled
 614       //NOTE: coordinates are (column, row) for the profiles
 615       if ( in->IsLowGain() ) {
 616         //fill the low gain histograms
 617         ((TProfile2D*)fPeakMinusPedLowGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), max - min);
 618         if (nPed>0) { // only fill pedestal info in case it could be calculated
 619           for ( i=0; i<nPed; i++) {
 620             ((TProfile2D*)fPedestalLowGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), pedSamples[i]);
 621           }
 622         }
 623       }
 624       else if ( in->IsHighGain() ) {
 625         //fill the high gain ones
 626         ((TProfile2D*)fPeakMinusPedHighGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), max - min);
 627         if (nPed>0) { // only fill pedestal info in case it could be calculated
 628           for ( i=0; i<nPed; i++) {
 629             ((TProfile2D*)fPedestalHighGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), pedSamples[i]);
 630           }
 631         }
 632         // for warning checks
 633         int idx = in->GetRow() + fRows * in->GetColumn();
 634         ((TH2F*)fPeakMinusPedHighGainHisto[arrayPos])->Fill(idx, max - min);
 635       }
 636       else if ( in->IsLEDMonData() ) {
 637         // for LED Mon data, the mapping class holds the gain info in the Row variable
 638         // and the Strip number in the Column..
 639         int gain = in->GetRow();
 640         int stripId = in->GetColumn();
 641         if (nPed>0 && stripId<fLEDRefs) {
 642           if (gain == 0) {
 643             for ( i=0; i<nPed; i++) {
 644               ((TProfile*)fPedestalLEDRefLowGain[arrayPos])->Fill(stripId, pedSamples[i]);
 645             }
 646           }
 647           else {
 648             for ( i=0; i<nPed; i++) {
 649               ((TProfile*)fPedestalLEDRefHighGain[arrayPos])->Fill(stripId, pedSamples[i]);
 650             }
 651           }
 652         }
 653       }
 654
 655       } // nsamples>0 check, some data found for this channel; not only trailer/header
 656     }// end while over channel
 657   }//end while over DDL's, of input stream
 658
 659
 660   return kTRUE;
 661 }
 662
 663 //_____________________________________________________________________
 664 Bool_t AliCaloCalibPedestal::SaveHistograms(TString fileName, Bool_t saveEmptyHistos)
 665 {
 666   //Saves all the histograms (or profiles, to be accurate) to the designated file
 667   ValidateProfiles(); // make sure histos/profiles exist
 668   TFile destFile(fileName, "recreate");
 669
 670   if (destFile.IsZombie()) {
 671     return kFALSE;
 672   }
 673
 674   destFile.cd();
 675
 676   for (int i = 0; i < fModules; i++) {
 677     if( ((TProfile2D *)fPeakMinusPedLowGain[i])->GetEntries() || saveEmptyHistos) {
 678       fPeakMinusPedLowGain[i]->Write();
 679     }
 680     if( ((TProfile2D *)fPeakMinusPedHighGain[i])->GetEntries() || saveEmptyHistos) {
 681       fPeakMinusPedHighGain[i]->Write();
 682     }
 683     if( ((TProfile2D *)fPedestalLowGain[i])->GetEntries() || saveEmptyHistos) {
 684       fPedestalLowGain[i]->Write();
 685     }
 686     if( ((TProfile2D *)fPedestalHighGain[i])->GetEntries() || saveEmptyHistos) {
 687       fPedestalHighGain[i]->Write();
 688     }
 689     if( ((TProfile *)fPedestalLEDRefLowGain[i])->GetEntries() || saveEmptyHistos) {
 690       fPedestalLEDRefLowGain[i]->Write();
 691     }
 692     if( ((TProfile *)fPedestalLEDRefHighGain[i])->GetEntries() || saveEmptyHistos) {
 693       fPedestalLEDRefHighGain[i]->Write();
 694     }
 695     if( ((TH2F *)fPeakMinusPedHighGainHisto[i])->GetEntries() || saveEmptyHistos) {
 696       fPeakMinusPedHighGainHisto[i]->Write();
 697     }
 698
 699   }
 700
 701   destFile.Close();
 702
 703   return kTRUE;
 704 }
 705
 706 //_____________________________________________________________________
 707 Bool_t AliCaloCalibPedestal::LoadReferenceCalib(TString fileName, TString objectName)
 708 {
 709
 710   //Make sure that the histograms created when loading the object are not destroyed as the file object is destroyed
 711   TH1::AddDirectory(kFALSE);
 712
 713   TFile *sourceFile = new TFile(fileName);
 714   if (sourceFile->IsZombie()) {
 715     return kFALSE;//We couldn't load the reference
 716   }
 717
 718   if (fReference) delete fReference;//Delete the reference object, if it already exists
 719   fReference = 0;
 720
 721   fReference = (AliCaloCalibPedestal*)sourceFile->Get(objectName);
 722
 723   if (!fReference || !(fReference->InheritsFrom(AliCaloCalibPedestal::Class())) || (fReference->GetDetectorType() != fDetType)) {
 724     if (fReference) delete fReference;//Delete the object, in case we had an object of the wrong type
 725     fReference = 0;
 726     return kFALSE;
 727   }
 728
 729   delete sourceFile;
 730
 731   //Reset the histogram ownership behaviour. NOTE: a better workaround would be good, since this may accidentally set AddDirectory to true, even
 732   //if we are called by someone who has set it to false...
 733   TH1::AddDirectory(kTRUE);
 734
 735   return kTRUE;//We succesfully loaded the object
 736 }
 737
 738
 739 //_____________________________________________________________________
 740 Bool_t AliCaloCalibPedestal::SetReference(AliCaloCalibPedestal *ref)
 741 {
 742   if (fReference) delete fReference;//Delete the reference object, if it already exists
 743   fReference = 0;
 744
 745   fReference = ref;
 746
 747   if (!fReference || (fReference->GetDetectorType() != fDetType)) {
 748     if (fReference) delete fReference;//Delete the object, in case we had an object of the wrong type
 749     fReference = 0;
 750     return kFALSE;
 751   }
 752
 753   return kTRUE;//We succesfully loaded the object
 754 }
 755
 756 //_____________________________________________________________________
 757 void AliCaloCalibPedestal::ValidateComparisonProfiles()
 758 {
 759   //Make sure the comparison histos exist
 760   if (!fPedestalLowGainDiff.IsEmpty()) return; //The profiles already exist. We just check one, because they're all created at
 761   //the same time
 762
 763
 764   //Then, loop for the requested number of modules
 765   TString title, name;
 766   for (int i = 0; i < fModules; i++) {
 767     //Pedestals, low gain
 768     name = "hPedlowgainDiff";
 769     name += i;
 770     title = "Pedestals difference, low gain, module ";
 771     title += i;
 772     fPedestalLowGainDiff.Add(new TProfile2D(name, title,
 773                                             fColumns, 0.0, fColumns,
 774                                             fRows, fRowMin, fRowMax,"s"));
 775
 776     //Pedestals, high gain
 777     name = "hPedhighgainDiff";
 778     name += i;
 779     title = "Pedestals difference, high gain, module ";
 780     title += i;
 781     fPedestalHighGainDiff.Add(new TProfile2D(name, title,
 782                                              fColumns, 0.0, fColumns,
 783                                              fRows, fRowMin, fRowMax,"s"));
 784
 785     //LED Ref/Mon pedestals, low gain
 786     name = "hPedestalLEDReflowgainDiff";
 787     name += i;
 788     title = "Pedestal difference LEDRef, low gain, module ";
 789     title += i;
 790     fPedestalLEDRefLowGainDiff.Add(new TProfile(name, title,
 791                                                 fLEDRefs, 0.0, fLEDRefs, "s"));
 792
 793     //LED Ref/Mon pedestals, high gain
 794     name = "hPedestalLEDRefhighgainDiff";
 795     name += i;
 796     title = "Pedestal difference LEDRef, high gain, module ";
 797     title += i;
 798     fPedestalLEDRefHighGainDiff.Add(new TProfile(name, title,
 799                                                  fLEDRefs, 0.0, fLEDRefs, "s"));
 800
 801     //Peak-Pedestals, high gain
 802     name = "hPeakMinusPedhighgainDiff";
 803     name += i;
 804     title = "Peak-Pedestal difference, high gain, module ";
 805     title += i;
 806     fPeakMinusPedHighGainDiff.Add(new TProfile2D(name, title,
 807                                                  fColumns, 0.0, fColumns,
 808                                                  fRows, fRowMin, fRowMax,"s"));
 809
 810     //Peak-Pedestals, low gain
 811     name = "hPeakMinusPedlowgainDiff";
 812     name += i;
 813     title = "Peak-Pedestal difference, low gain, module ";
 814     title += i;
 815     fPeakMinusPedLowGainDiff.Add(new TProfile2D(name, title,
 816                                                 fColumns, 0.0, fColumns,
 817                                                 fRows, fRowMin, fRowMax,"s"));
 818
 819     //Pedestals, low gain
 820     name = "hPedlowgainRatio";
 821     name += i;
 822     title = "Pedestals ratio, low gain, module ";
 823     title += i;
 824     fPedestalLowGainRatio.Add(new TProfile2D(name, title,
 825                                              fColumns, 0.0, fColumns,
 826                                              fRows, fRowMin, fRowMax,"s"));
 827
 828     //Pedestals, high gain
 829     name = "hPedhighgainRatio";
 830     name += i;
 831     title = "Pedestals ratio, high gain, module ";
 832     title += i;
 833     fPedestalHighGainRatio.Add(new TProfile2D(name, title,
 834                                               fColumns, 0.0, fColumns,
 835                                               fRows, fRowMin, fRowMax,"s"));
 836
 837     //LED Ref/Mon pedestals, low gain
 838     name = "hPedestalLEDReflowgainRatio";
 839     name += i;
 840     title = "Pedestal ratio LEDRef, low gain, module ";
 841     title += i;
 842     fPedestalLEDRefLowGainRatio.Add(new TProfile(name, title,
 843                                                  fLEDRefs, 0.0, fLEDRefs, "s"));
 844
 845     //LED Ref/Mon pedestals, high gain
 846     name = "hPedestalLEDRefhighgainRatio";
 847     name += i;
 848     title = "Pedestal ratio LEDRef, high gain, module ";
 849     title += i;
 850     fPedestalLEDRefHighGainRatio.Add(new TProfile(name, title,
 851                                                   fLEDRefs, 0.0, fLEDRefs, "s"));
 852
 853     //Peak-Pedestals, low gain
 854     name = "hPeakMinusPedlowgainRatio";
 855     name += i;
 856     title = "Peak-Pedestal ratio, low gain, module ";
 857     title += i;
 858     fPeakMinusPedLowGainRatio.Add(new TProfile2D(name, title,
 859                                                  fColumns, 0.0, fColumns,
 860                                                  fRows, fRowMin, fRowMax,"s"));
 861
 862     //Peak-Pedestals, high gain
 863     name = "hPeakMinusPedhighgainRatio";
 864     name += i;
 865     title = "Peak-Pedestal ratio, high gain, module ";
 866     title += i;
 867     fPeakMinusPedHighGainRatio.Add(new TProfile2D(name, title,
 868                                                   fColumns, 0.0, fColumns,
 869                                                   fRows, fRowMin, fRowMax,"s"));
 870
 871   }//end for nModules create the histograms
 872 }
 873
 874 //_____________________________________________________________________
 875 void AliCaloCalibPedestal::ComputeDiffAndRatio()
 876 {
 877   // calculate differences and ratios relative to a reference
 878   ValidateProfiles(); // make sure histos/profiles exist
 879   ValidateComparisonProfiles();//Make sure the comparison histos exist
 880
 881   if (!fReference) {
 882     return;//Return if the reference object isn't loaded
 883   }
 884
 885   int bin = 0;
 886   double diff = 0;
 887   double ratio = 1;
 888   for (int i = 0; i < fModules; i++) {
 889     //For computing the difference, we cannot simply do TProfile2D->Add(), because that subtracts the sum of all entries,
 890     //which means that the mean of the new profile will not be the difference of the means. So do it by hand:
 891     for (int j = 0; j < fColumns; j++) {
 892       for (int k = 0; k < fRows; k++) {
 893         bin = ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->GetBin(j+1, k+1);//Note that we assume here that all histos have the same structure...
 894
 895         if (fReference->GetPeakProfileHighGain(i)->GetBinContent(bin) > 0) {
 896           diff = GetPeakProfileHighGain(i)->GetBinContent(bin) - fReference->GetPeakProfileHighGain(i)->GetBinContent(bin);
 897           ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->SetBinContent(bin, diff);
 898           ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->SetBinEntries(bin, 1);
 899           ratio = GetPeakProfileHighGain(i)->GetBinContent(bin) / fReference->GetPeakProfileHighGain(i)->GetBinContent(bin);
 900           ((TProfile2D*)fPeakMinusPedHighGainRatio[i])->SetBinContent(bin, ratio);
 901           ((TProfile2D*)fPeakMinusPedHighGainRatio[i])->SetBinEntries(bin, 1);
 902         }
 903
 904         if (fReference->GetPeakProfileLowGain(i)->GetBinContent(bin) > 0) {
 905           diff = GetPeakProfileLowGain(i)->GetBinContent(bin) - fReference->GetPeakProfileLowGain(i)->GetBinContent(bin);
 906           ((TProfile2D*)fPeakMinusPedLowGainDiff[i])->SetBinContent(bin, diff);
 907           ((TProfile2D*)fPeakMinusPedLowGainDiff[i])->SetBinEntries(bin, 1);
 908           ratio = GetPeakProfileLowGain(i)->GetBinContent(bin) / fReference->GetPeakProfileLowGain(i)->GetBinContent(bin);
 909           ((TProfile2D*)fPeakMinusPedLowGainRatio[i])->SetBinContent(bin, ratio);
 910           ((TProfile2D*)fPeakMinusPedLowGainRatio[i])->SetBinEntries(bin, 1);
 911         }
 912
 913         if (fReference->GetPedProfileHighGain(i)->GetBinContent(bin) > 0) {
 914           diff = GetPedProfileHighGain(i)->GetBinContent(bin) - fReference->GetPedProfileHighGain(i)->GetBinContent(bin);
 915           ((TProfile2D*)fPedestalHighGainDiff[i])->SetBinContent(bin, diff);
 916           ((TProfile2D*)fPedestalHighGainDiff[i])->SetBinEntries(bin, 1);
 917           ratio = GetPedProfileHighGain(i)->GetBinContent(bin) / fReference->GetPedProfileHighGain(i)->GetBinContent(bin);
 918           ((TProfile2D*)fPedestalHighGainRatio[i])->SetBinContent(bin, ratio);
 919           ((TProfile2D*)fPedestalHighGainRatio[i])->SetBinEntries(bin, 1);
 920         }
 921
 922         if (fReference->GetPedProfileLowGain(i)->GetBinContent(bin) > 0) {
 923           diff = GetPedProfileLowGain(i)->GetBinContent(bin) - fReference->GetPedProfileLowGain(i)->GetBinContent(bin);
 924           ((TProfile2D*)fPedestalLowGainDiff[i])->SetBinContent(bin, diff);
 925           ((TProfile2D*)fPedestalLowGainDiff[i])->SetBinEntries(bin, 1);
 926           ratio = GetPedProfileLowGain(i)->GetBinContent(bin) / fReference->GetPedProfileLowGain(i)->GetBinContent(bin);
 927           ((TProfile2D*)fPedestalLowGainRatio[i])->SetBinContent(bin, ratio);
 928           ((TProfile2D*)fPedestalLowGainRatio[i])->SetBinEntries(bin, 1);
 929         }
 930
 931       } // rows
 932     } // columns
 933
 934     // same for LED Ref/Mon channels
 935     for (int j = 0; j <= fLEDRefs; j++) {
 936       bin = j+1;//Note that we assume here that all histos have the same structure...
 937
 938       if (fReference->GetPedLEDRefProfileHighGain(i)->GetBinContent(bin) > 0) {
 939         diff = GetPedLEDRefProfileHighGain(i)->GetBinContent(bin) - fReference->GetPedLEDRefProfileHighGain(i)->GetBinContent(bin);
 940         ((TProfile*)fPedestalLEDRefHighGainDiff[i])->SetBinContent(bin, diff);
 941         ((TProfile*)fPedestalLEDRefHighGainDiff[i])->SetBinEntries(bin, 1);
 942         ratio = GetPedLEDRefProfileHighGain(i)->GetBinContent(bin) / fReference->GetPedLEDRefProfileHighGain(i)->GetBinContent(bin);
 943         ((TProfile*)fPedestalLEDRefHighGainRatio[i])->SetBinContent(bin, ratio);
 944         ((TProfile*)fPedestalLEDRefHighGainRatio[i])->SetBinEntries(bin, 1);
 945       }
 946
 947       if (fReference->GetPedLEDRefProfileLowGain(i)->GetBinContent(bin) > 0) {
 948         diff = GetPedLEDRefProfileLowGain(i)->GetBinContent(bin) - fReference->GetPedLEDRefProfileLowGain(i)->GetBinContent(bin);
 949         ((TProfile*)fPedestalLEDRefLowGainDiff[i])->SetBinContent(bin, diff);
 950         ((TProfile*)fPedestalLEDRefLowGainDiff[i])->SetBinEntries(bin, 1);
 951         ratio = GetPedLEDRefProfileLowGain(i)->GetBinContent(bin) / fReference->GetPedLEDRefProfileLowGain(i)->GetBinContent(bin);
 952         ((TProfile*)fPedestalLEDRefLowGainRatio[i])->SetBinContent(bin, ratio);
 953         ((TProfile*)fPedestalLEDRefLowGainRatio[i])->SetBinEntries(bin, 1);
 954       }
 955
 956     }
 957
 958   } // modules
 959
 960 }
 961
 962 //_____________________________________________________________________
 963 void AliCaloCalibPedestal::ComputeHotAndWarningTowers(const char * hotMapFile)
 964 { // look for hot/noisy towers
 965   ValidateProfiles(); // make sure histos/profiles exist
 966   ofstream * fout = 0;
 967   char name[512];//Quite a long temp buffer, just in case the filename includes a path
 968
 969   if (hotMapFile) {
 970     snprintf(name, 512, "%s.txt", hotMapFile);
 971     fout = new ofstream(name);
 972     if (!fout->is_open()) {
 973       delete fout;
 974       fout = 0;//Set the pointer to empty if the file was not opened
 975     }
 976   }
 977
 978   for(int i = 0; i < fModules; i++){
 979
 980     //first we compute the peak-pedestal distribution for each supermodule...
 981     if( GetPeakHighGainHisto(i)->GetEntries() > 0 ) {
 982       double min = GetPeakProfileHighGain(i)->GetBinContent(GetPeakProfileHighGain(i)->GetMinimumBin());
 983       double max = GetPeakProfileHighGain(i)->GetBinContent(GetPeakProfileHighGain(i)->GetMaximumBin());
 984       TH1D *hPeakFit = new TH1D(Form("hFit_%d", i), Form("hFit_%d", i), (int)((max-min)*10), min-1, max+1);
 985
 986       for (int j = 1; j <= fColumns; j++) {
 987         for (int k = 1; k <= fRows; k++) {
 988           hPeakFit->Fill(GetPeakProfileHighGain(i)->GetBinContent(j, k));
 989         }
 990       }
 991
 992       //...and then we try to fit it
 993       double mean  = hPeakFit->GetMean();
 994       double sigma = hPeakFit->GetRMS();
 995       try {
 996         hPeakFit->Fit("gaus", "OQ", "",  mean - 3*sigma, mean + 3*sigma);
 997         mean  = hPeakFit->GetFunction("gaus")->GetParameter(1);
 998         sigma = hPeakFit->GetFunction("gaus")->GetParameter(2);
 999       }
1000       catch (const std::exception & e) {
1001         printf("AliCaloCalibPedestal: TH1D PeakFit exception %s", e.what());
1002       }
1003       //hPeakFit->Draw();
1004
1005       delete hPeakFit;
1006
1007       //Then we look for warm/hot towers
1008       TH2F * hPeak2D = GetPeakHighGainHisto(i);
1009       hPeak2D->GetYaxis()->SetRangeUser( fWarningThreshold, hPeak2D->GetYaxis()->GetBinUpEdge(hPeak2D->GetNbinsY()) );
1010
1011       int idx = 0 ;
1012       int warnCounter = 0;
1013       for (int j = 1; j <= fColumns; j++) {
1014         for (int k = 1; k <= fRows; k++) {
1015           //we start looking for warm/warning towers...
1016           // histogram x-axis index
1017           idx = k-1 + fRows*(j-1); // this is what is used in the Fill call
1018           hPeak2D->GetXaxis()->SetRangeUser(idx, idx);
1019           warnCounter = (int) hPeak2D->Integral();
1020           if(warnCounter > fNEvents * fWarningFraction) {
1021             ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kWarning);
1022             /* printf("mod %d col %d row %d warnCounter %d - status %d\n",
1023                i, j-1, k-1, warnCounter, (int) (kWarning)); */
1024           }
1025           //...then we look for hot ones (towers whose values are greater than mean + X*sigma)
1026           if(GetPeakProfileHighGain(i)->GetBinContent(j, k) > mean + fHotSigma*sigma ) {
1027             ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kHot);
1028             /* printf("mod %d col %d row %d  binc %d - status %d\n",
1029                i, j-1, k-1, (int)(GetPeakProfileHighGain(i)->GetBinContent(j, k)), (int) (kHot)); */
1030           }
1031
1032           //Write the status to the hot/warm map file, if the file is open.
1033           // module - column - row - status (1=dead, 2= warm/warning , 3 = hot, see .h file enum)
1034           if (fout && ((TH2D*)fDeadMap[i])->GetBinContent(j, k) > 1) {
1035
1036             (*fout) << i << " "
1037                     << (j - 1) << " "
1038                     << (k - 1) << " "
1039                     << ((TH2D*)fDeadMap[i])->GetBinContent(j, k) << endl;               }
1040
1041         }
1042       }
1043
1044     }
1045   }
1046   return;
1047 }
1048
1049 //_____________________________________________________________________
1050 void AliCaloCalibPedestal::ComputeDeadTowers(const char * deadMapFile)
1051 {
1052   ValidateProfiles(); // make sure histos/profiles exist
1053   //Computes the number of dead towers etc etc into memory, after this you can call the GetDead... -functions
1054   int countTot = 0;
1055   int countNew = 0;
1056   int countRes = 0;
1057   ofstream * fout = 0;
1058   ofstream * diff = 0;
1059   char name[512];//Quite a long temp buffer, just in case the filename includes a path
1060
1061   if (deadMapFile) {
1062     snprintf(name, 512, "%s.txt", deadMapFile);
1063     fout = new ofstream(name);
1064     snprintf(name, 512, "%sdiff.txt", deadMapFile);
1065     diff = new ofstream(name);
1066     if (!fout->is_open()) {
1067       delete fout;
1068       fout = 0;//Set the pointer to empty if the file was not opened
1069     }
1070     if (!diff->is_open()) {
1071       delete diff;
1072       diff = 0;//Set the pointer to empty if the file was not opened
1073     }
1074   }
1075
1076   for (int i = 0; i < fModules; i++) {
1077     if (GetPeakProfileHighGain(i)->GetEntries() > 0) { //don't care about empty histos
1078       for (int j = 1; j <= fColumns; j++) {
1079         for (int k = 1; k <= fRows; k++) {
1080
1081           if (GetPeakProfileHighGain(i)->GetBinContent(j, k) < fDeadThreshold) {//It's dead
1082             countTot++;//One more dead total
1083             if (fout) {
1084               (*fout) << i << " "
1085                       << (j - 1) << " "
1086                       << (k - 1) << " "
1087                       << "1" << " "
1088                       << "0" << endl;//Write the status to the deadmap file, if the file is open.
1089             }
1090
1091             if (fReference && fReference->GetPeakProfileHighGain(i)->GetBinContent(j, k) >= fDeadThreshold) {
1092               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kRecentlyDeceased);
1093               countNew++;//This tower wasn't dead before!
1094               if (diff) {
1095                 ( *diff) << i << " "
1096                          << (j - 1) << " "
1097                          << (k - 1) << " "
1098                          << "1" << " "
1099                          << "0" << endl;//Write the status to the deadmap difference file, if the file is open.
1100               }
1101             }
1102             else {
1103               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kDead);//This has been dead before. Nothing new
1104             }
1105           }
1106           else { //It's ALIVE!!
1107             //Don't bother with writing the live ones.
1108             if (fReference && fReference->GetPeakProfileHighGain(i)->GetBinContent(j, k) < fDeadThreshold) {
1109               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kResurrected);
1110               countRes++; //This tower was dead before => it's a miracle! :P
1111               if (diff) {
1112                 (*diff) << i << " "
1113                         << (j - 1) << " "
1114                         << (k - 1) << " "
1115                         << "1" << " "
1116                         << "1" << endl;//Write the status to the deadmap difference file, if the file is open.
1117               }
1118             }
1119             else {
1120               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kAlive);
1121             }
1122           }
1123
1124         }//end for k/rows
1125       }//end for j/columns
1126     }//end if GetEntries >= 0
1127
1128   }//end for modules
1129
1130  if (fout) {
1131    fout->close();
1132    delete fout;
1133  }
1134
1135  fDeadTowers = countTot;
1136  fNewDeadTowers = countNew;
1137  fResurrectedTowers = countRes;
1138 }
1139
1140 //_____________________________________________________________________
1141 Bool_t AliCaloCalibPedestal::IsBadChannel(int imod, int icol, int irow) const
1142 {
1143   // Check if status info histo exists
1144   if (!fDeadMap[imod]) {
1145     return kFALSE;
1146   }
1147
1148   //Check if channel is dead or hot.
1149   Int_t status =  (Int_t) ( ((TH2D*)fDeadMap[imod])->GetBinContent(icol,irow) );
1150   if(status == kAlive)
1151     return kFALSE;
1152   else
1153     return kTRUE;
1154
1155 }
1156
1157 //_____________________________________________________________________
1158 void AliCaloCalibPedestal::SetChannelStatus(int imod, int icol, int irow, int status)
1159 {
1160   ValidateProfiles(); // make sure histos/profiles exist
1161   //Set status of channel dead, hot, alive ...
1162   ((TH2D*)fDeadMap[imod])->SetBinContent(icol, irow, status);
1163 }