- Reset TProcessID count after each event
[u/mrichter/AliRoot.git] / 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 "TH1.h"
38 #include "TFile.h"
39
40 #include <fstream>
41 #include <iostream>
42
43 #include "AliCaloRawStream.h"
44
45 //The include file
46 #include "AliCaloCalibPedestal.h"
47
48 ClassImp(AliCaloCalibPedestal)
49
50 using namespace std;
51
52 // ctor; initialize everything in order to avoid compiler warnings
53 AliCaloCalibPedestal::AliCaloCalibPedestal(kDetType detectorType) :  
54   TObject(),
55   fPedestalLowGain(),
56   fPedestalHighGain(),
57   fPeakMinusPedLowGain(),
58   fPeakMinusPedHighGain(),
59   fPedestalLowGainDiff(),
60   fPedestalHighGainDiff(),
61   fPeakMinusPedLowGainDiff(),
62   fPeakMinusPedHighGainDiff(),
63   fPedestalLowGainRatio(),
64   fPedestalHighGainRatio(),
65   fPeakMinusPedLowGainRatio(),
66   fPeakMinusPedHighGainRatio(),
67   fDeadMap(),
68   fDeadTowers(0),
69   fNewDeadTowers(0),
70   fResurrectedTowers(0),
71   fReference(0),
72   fDetType(kNone),
73   fColumns(0),
74   fRows(0),
75   fModules(0),
76   fRunNumber(-1)
77 {
78   //Default constructor. First we set the detector-type related constants.
79   if (detectorType == kPhos) {
80     fColumns = fgkPhosCols;
81     fRows = fgkPhosRows;
82     fModules = fgkPhosModules;
83   } 
84   else {
85     //We'll just trust the enum to keep everything in line, so that if detectorType
86     //isn't kPhos then it is kEmCal. Note, however, that this is not necessarily the
87     //case, if someone intentionally gives another number
88     fColumns = fgkEmCalCols;
89     fRows = fgkEmCalRows;
90     fModules = fgkEmCalModules;
91   } 
92   fDetType = detectorType;
93  
94   //Then, loop for the requested number of modules
95   TString title, name;
96   for (int i = 0; i < fModules; i++) {
97     //Pedestals, low gain
98     name = "hPedlowgain";
99     name += i;
100     title = "Pedestals, low gain, module ";
101     title += i; 
102     fPedestalLowGain.Add(new TProfile2D(name, title,
103                                         fColumns, 0.0, fColumns, 
104                                         fRows, -fRows, 0.0));
105   
106     //Pedestals, high gain
107     name = "hPedhighgain";
108     name += i;
109     title = "Pedestals, high gain, module ";
110     title += i; 
111     fPedestalHighGain.Add(new TProfile2D(name, title,
112                                          fColumns, 0.0, fColumns, 
113                                          fRows, -fRows, 0.0));
114   
115     //Peak-Pedestals, low gain
116     name = "hPeakMinusPedlowgain";
117     name += i;
118     title = "Peak-Pedestal, low gain, module ";
119     title += i; 
120     fPeakMinusPedLowGain.Add(new TProfile2D(name, title,
121                                             fColumns, 0.0, fColumns, 
122                                             fRows, -fRows, 0.0));
123   
124     //Peak-Pedestals, high gain
125     name = "hPeakMinusPedhighgain";
126     name += i;
127     title = "Peak-Pedestal, high gain, module ";
128     title += i; 
129     fPeakMinusPedHighGain.Add(new TProfile2D(name, title,
130                                              fColumns, 0.0, fColumns, 
131                                              fRows, -fRows, 0.0));
132   
133     name = "hDeadMap";
134     name += i;
135     title = "Dead map, module ";
136     title += i;
137     fDeadMap.Add(new TH2D(name, title, fColumns, 0.0, fColumns, 
138                           fRows, -fRows, 0.0));
139   
140   }//end for nModules create the histograms
141  
142   //Compress the arrays, in order to remove the empty objects (a 16 slot array is created by default)
143   fPedestalLowGain.Compress();
144   fPedestalHighGain.Compress();
145   fPeakMinusPedLowGain.Compress();
146   fPeakMinusPedHighGain.Compress();
147   fDeadMap.Compress();
148   //Make them the owners of the profiles, so we don't need to care about deleting them
149   //fPedestalLowGain.SetOwner();
150   //fPedestalHighGain.SetOwner();
151   //fPeakMinusPedLowGain.SetOwner();
152   //fPeakMinusPedHighGain.SetOwner();
153   
154 }
155
156 // dtor
157 //_____________________________________________________________________
158 AliCaloCalibPedestal::~AliCaloCalibPedestal()
159 {
160   if (fReference) delete fReference;//Delete the reference object, if it has been loaded
161   //TObjArray will delete the histos/profiles when it is deleted.
162 }
163
164 // copy ctor
165 //_____________________________________________________________________
166 AliCaloCalibPedestal::AliCaloCalibPedestal(const AliCaloCalibPedestal &ped) :
167   TObject(ped),
168   fPedestalLowGain(),
169   fPedestalHighGain(),
170   fPeakMinusPedLowGain(),
171   fPeakMinusPedHighGain(),
172   fPedestalLowGainDiff(),
173   fPedestalHighGainDiff(),
174   fPeakMinusPedLowGainDiff(),
175   fPeakMinusPedHighGainDiff(),
176   fPedestalLowGainRatio(),
177   fPedestalHighGainRatio(),
178   fPeakMinusPedLowGainRatio(),
179   fPeakMinusPedHighGainRatio(),
180   fDeadMap(),
181   fDeadTowers(ped.GetDeadTowerCount()),
182   fNewDeadTowers(ped.GetDeadTowerNew()),
183   fResurrectedTowers(ped.GetDeadTowerResurrected()),
184   fReference( 0 ), //! note that we do not try to copy the reference info here
185   fDetType(ped.GetDetectorType()),
186   fColumns(ped.GetColumns()),
187   fRows(ped.GetRows()),
188   fModules(ped.GetModules()),
189   fRunNumber(ped.GetRunNumber())
190 {
191   // Then the ObjArray ones; we add the histograms rather than trying TObjArray = assignment
192   //DS: this has not really been tested yet..
193   for (int i = 0; i < fModules; i++) {
194     fPedestalLowGain.Add( ped.GetPedProfileLowGain(i) );
195     fPedestalHighGain.Add( ped.GetPedProfileHighGain(i) );
196     fPeakMinusPedLowGain.Add( ped.GetPeakProfileLowGain(i) );
197     fPeakMinusPedHighGain.Add( ped.GetPeakProfileHighGain(i) );
198
199     fDeadMap.Add( ped.GetDeadMap(i) );  
200   }//end for nModules 
201  
202   //Compress the arrays, in order to remove the empty objects (a 16 slot array is created by default)
203   fPedestalLowGain.Compress();
204   fPedestalHighGain.Compress();
205   fPeakMinusPedLowGain.Compress();
206   fPeakMinusPedHighGain.Compress();
207   fDeadMap.Compress();
208 }
209
210 // assignment operator; use copy ctor to make life easy..
211 //_____________________________________________________________________
212 AliCaloCalibPedestal& AliCaloCalibPedestal::operator = (const AliCaloCalibPedestal &source)
213 {
214   // assignment operator; use copy ctor
215   if (&source == this) return *this;
216
217   new (this) AliCaloCalibPedestal(source);
218   return *this;
219 }
220
221 //_____________________________________________________________________
222 void AliCaloCalibPedestal::Reset()
223 {
224   // Reset all arrays/histograms
225   for (int i = 0; i < fModules; i++) {
226     GetPedProfileLowGain(i)->Reset();
227     GetPedProfileHighGain(i)->Reset();
228     GetPeakProfileLowGain(i)->Reset();
229     GetPeakProfileHighGain(i)->Reset();
230     GetDeadMap(i)->Reset();
231     
232     if (!fPedestalLowGainDiff.IsEmpty()) {
233       //This means that the comparison profiles have been created.
234   
235       GetPedProfileLowGainDiff(i)->Reset();
236       GetPedProfileHighGainDiff(i)->Reset();
237       GetPeakProfileLowGainDiff(i)->Reset();
238       GetPeakProfileHighGainDiff(i)->Reset();
239       
240       GetPedProfileLowGainRatio(i)->Reset();
241       GetPedProfileHighGainRatio(i)->Reset();
242       GetPeakProfileLowGainRatio(i)->Reset();
243       GetPeakProfileHighGainRatio(i)->Reset();
244     }
245   }
246   fDeadTowers = 0;
247   fNewDeadTowers = 0;
248   fResurrectedTowers = 0;
249  
250   //To think about: should fReference be deleted too?... let's not do it this time, at least...
251 }
252
253 //_____________________________________________________________________
254 Bool_t AliCaloCalibPedestal::ProcessEvent(AliCaloRawStream *in)
255
256   // Method to process=analyze one event in the data stream
257   if (!in) return kFALSE; //Return right away if there's a null pointer
258   
259   in->SetOldRCUFormat(kTRUE);
260   
261   int sample, i = 0; //The sample temp, and the sample number in current event.
262   int max = fgkSampleMin, min = fgkSampleMax;//Use these for picking the pedestal
263   int gain = 0;
264   
265   while (in->Next()) {
266     sample = in->GetSignal(); //Get the adc signal
267     if (sample < min) min = sample;
268     if (sample > max) max = sample;
269     i++;
270     if ( i >= in->GetTimeLength()) {
271       //If we're here then we're done with this tower
272       gain = 1 - in->IsLowGain();
273       
274       int arrayPos = in->GetModule(); //The modules are numbered starting from 0
275       if (arrayPos >= fModules) {
276         //TODO: return an error message, if appopriate (perhaps if debug>0?)
277         return kFALSE;
278       } 
279     
280       //Debug
281       if (arrayPos < 0 || arrayPos >= fModules) {
282         printf("Oh no: arrayPos = %i.\n", arrayPos); 
283       }
284
285       //NOTE: coordinates are (column, row) for the profiles
286       if (gain == 0) {
287         //fill the low gain histograms
288         ((TProfile2D*)fPedestalLowGain[arrayPos])->Fill(in->GetColumn(), -in->GetRow() - 1, min);
289         ((TProfile2D*)fPeakMinusPedLowGain[arrayPos])->Fill(in->GetColumn(), -in->GetRow() - 1, max - min);
290       } 
291       else {//fill the high gain ones
292         ((TProfile2D*)fPedestalHighGain[arrayPos])->Fill(in->GetColumn(), -in->GetRow() - 1, min);
293         ((TProfile2D*)fPeakMinusPedHighGain[arrayPos])->Fill(in->GetColumn(), -in->GetRow() - 1, max - min);
294       }//end if gain
295       
296       max = fgkSampleMin; min = fgkSampleMax;
297       i = 0;
298     
299     }//End if end of tower
300    
301   }//end while, of stream
302   
303   return kTRUE;
304 }
305
306 //_____________________________________________________________________
307 Bool_t AliCaloCalibPedestal::SaveHistograms(TString fileName, Bool_t saveEmptyHistos)
308 {
309   //Saves all the histograms (or profiles, to be accurate) to the designated file
310   
311   TFile destFile(fileName, "recreate");
312   
313   if (destFile.IsZombie()) {
314     return kFALSE;
315   }
316   
317   destFile.cd();
318   
319   for (int i = 0; i < fModules; i++) {
320     if( ((TProfile2D *)fPeakMinusPedLowGain[i])->GetEntries() || saveEmptyHistos) {
321       fPeakMinusPedLowGain[i]->Write();
322     }
323     if( ((TProfile2D *)fPeakMinusPedHighGain[i])->GetEntries() || saveEmptyHistos) { 
324       fPeakMinusPedHighGain[i]->Write();
325     }
326     if( ((TProfile2D *)fPedestalLowGain[i])->GetEntries() || saveEmptyHistos) {
327       fPedestalLowGain[i]->Write();
328     }
329     if( ((TProfile2D *)fPedestalHighGain[i])->GetEntries() || saveEmptyHistos) {
330       fPedestalHighGain[i]->Write();
331     }
332   } 
333   
334   destFile.Close();
335   
336   return kTRUE;
337 }
338
339 //_____________________________________________________________________
340 Bool_t AliCaloCalibPedestal::LoadReferenceCalib(TString fileName, TString objectName)
341 {
342   
343   //Make sure that the histograms created when loading the object are not destroyed as the file object is destroyed
344   TH1::AddDirectory(kFALSE);
345   
346   TFile *sourceFile = new TFile(fileName);
347   if (sourceFile->IsZombie()) {
348     return kFALSE;//We couldn't load the reference
349   }
350
351   if (fReference) delete fReference;//Delete the reference object, if it already exists
352   fReference = 0;
353   
354   fReference = (AliCaloCalibPedestal*)sourceFile->Get(objectName);
355  
356   if (!fReference || !(fReference->InheritsFrom(AliCaloCalibPedestal::Class())) || (fReference->GetDetectorType() != fDetType)) {
357     if (fReference) delete fReference;//Delete the object, in case we had an object of the wrong type
358     fReference = 0;
359     return kFALSE;
360   }
361         
362   delete sourceFile;
363  
364   //Reset the histogram ownership behaviour. NOTE: a better workaround would be good, since this may accidentally set AddDirectory to true, even
365   //if we are called by someone who has set it to false...
366   TH1::AddDirectory(kTRUE);
367  
368   return kTRUE;//We succesfully loaded the object
369 }
370
371 //_____________________________________________________________________
372 void AliCaloCalibPedestal::ValidateComparisonProfiles()
373 {
374   //Make sure the comparison histos exist
375   if (!fPedestalLowGainDiff.IsEmpty()) return; //The profiles already exist. We just check one, because they're all created at
376   //the same time
377                                                 
378                                                 
379   //Then, loop for the requested number of modules
380   TString title, name;
381   for (int i = 0; i < fModules; i++) {
382     //Pedestals, low gain
383     name = "hPedlowgainDiff";
384     name += i;
385     title = "Pedestals difference, low gain, module ";
386     title += i; 
387     fPedestalLowGainDiff.Add(new TProfile2D(name, title,
388                                             fColumns, 0.0, fColumns, 
389                                             fRows, -fRows, 0.0));
390   
391     //Pedestals, high gain
392     name = "hPedhighgainDiff";
393     name += i;
394     title = "Pedestals difference, high gain, module ";
395     title += i; 
396     fPedestalHighGainDiff.Add(new TProfile2D(name, title,
397                                              fColumns, 0.0, fColumns, 
398                                              fRows, -fRows, 0.0));
399   
400     //Peak-Pedestals, low gain
401     name = "hPeakMinusPedlowgainDiff";
402     name += i;
403     title = "Peak-Pedestal difference, low gain, module ";
404     title += i; 
405     fPeakMinusPedLowGainDiff.Add(new TProfile2D(name, title,
406                                                 fColumns, 0.0, fColumns, 
407                                                 fRows, -fRows, 0.0));
408   
409     //Peak-Pedestals, high gain
410     name = "hPeakMinusPedhighgainDiff";
411     name += i;
412     title = "Peak-Pedestal difference, high gain, module ";
413     title += i; 
414     fPeakMinusPedHighGainDiff.Add(new TProfile2D(name, title,
415                                                  fColumns, 0.0, fColumns, 
416                                                  fRows, -fRows, 0.0));
417   
418     //Pedestals, low gain
419     name = "hPedlowgainRatio";
420     name += i;
421     title = "Pedestals ratio, low gain, module ";
422     title += i; 
423     fPedestalLowGainRatio.Add(new TProfile2D(name, title,
424                                              fColumns, 0.0, fColumns, 
425                                              fRows, -fRows, 0.0));
426   
427     //Pedestals, high gain
428     name = "hPedhighgainRatio";
429     name += i;
430     title = "Pedestals ratio, high gain, module ";
431     title += i; 
432     fPedestalHighGainRatio.Add(new TProfile2D(name, title,
433                                               fColumns, 0.0, fColumns, 
434                                               fRows, -fRows, 0.0));
435   
436     //Peak-Pedestals, low gain
437     name = "hPeakMinusPedlowgainRatio";
438     name += i;
439     title = "Peak-Pedestal ratio, low gain, module ";
440     title += i; 
441     fPeakMinusPedLowGainRatio.Add(new TProfile2D(name, title,
442                                                  fColumns, 0.0, fColumns, 
443                                                  fRows, -fRows, 0.0));
444   
445     //Peak-Pedestals, high gain
446     name = "hPeakMinusPedhighgainRatio";
447     name += i;
448     title = "Peak-Pedestal ratio, high gain, module ";
449     title += i; 
450     fPeakMinusPedHighGainRatio.Add(new TProfile2D(name, title,
451                                                   fColumns, 0.0, fColumns, 
452                                                   fRows, -fRows, 0.0));
453     
454   }//end for nModules create the histograms
455 }
456
457 //_____________________________________________________________________
458 void AliCaloCalibPedestal::ComputeDiffAndRatio()
459 {
460   // calculate differences and ratios relative to a reference
461   ValidateComparisonProfiles();//Make sure the comparison histos exist
462  
463   if (!fReference) {
464     return;//Return if the reference object isn't loaded
465   }
466
467   for (int i = 0; i < fModules; i++) {
468     //Compute the ratio of the histograms
469     
470     ((TProfile2D*)fPedestalLowGainRatio[i])->Divide(GetPedProfileLowGain(i), fReference->GetPedProfileLowGain(i), 1.0, 1.0);
471     ((TProfile2D*)fPedestalHighGainRatio[i])->Divide(GetPedProfileHighGain(i), fReference->GetPedProfileHighGain(i), 1.0, 1.0);
472     ((TProfile2D*)fPeakMinusPedLowGainRatio[i])->Divide(GetPeakProfileLowGain(i), fReference->GetPeakProfileLowGain(i), 1.0, 1.0);
473     ((TProfile2D*)fPeakMinusPedHighGainRatio[i])->Divide(GetPeakProfileHighGain(i), fReference->GetPeakProfileHighGain(i), 1.0, 1.0);
474   
475     //For computing the difference, we cannot simply do TProfile2D->Add(), because that subtracts the sum of all entries,
476     //which means that the mean of the new profile will not be the difference of the means. So do it by hand:
477     for (int j = 0; j <= fColumns; j++) {
478       for (int k = 0; k <= fRows; k++) {
479         int bin = ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->GetBin(j+1, k+1);//Note that we assume here that all histos have the same structure...
480         double diff = fReference->GetPeakProfileHighGain(i)->GetBinContent(bin) - GetPeakProfileHighGain(i)->GetBinContent(bin);
481         ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->SetBinContent(j+1, k+1, diff);
482         ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->SetBinEntries(bin, 1);
483
484         diff = fReference->GetPeakProfileLowGain(i)->GetBinContent(bin) - GetPeakProfileLowGain(i)->GetBinContent(bin);
485         ((TProfile2D*)fPeakMinusPedLowGainDiff[i])->SetBinContent(j+1, k+1, diff);
486         ((TProfile2D*)fPeakMinusPedLowGainDiff[i])->SetBinEntries(bin, 1);
487     
488         diff = fReference->GetPedProfileHighGain(i)->GetBinContent(bin) - GetPedProfileHighGain(i)->GetBinContent(bin);
489         ((TProfile2D*)fPedestalHighGainDiff[i])->SetBinContent(j+1, k+1, diff);
490         ((TProfile2D*)fPedestalHighGainDiff[i])->SetBinEntries(bin, 1);
491
492         diff = fReference->GetPedProfileLowGain(i)->GetBinContent(bin) - GetPedProfileLowGain(i)->GetBinContent(bin);
493         ((TProfile2D*)fPedestalLowGainDiff[i])->SetBinContent(j+1, k+1, diff);
494         ((TProfile2D*)fPedestalLowGainDiff[i])->SetBinEntries(bin, 1);
495        
496       } // rows
497     } // columns
498     
499   } // modules
500  
501 }
502
503 //_____________________________________________________________________
504 void AliCaloCalibPedestal::ComputeDeadTowers(int threshold, const char * deadMapFile)
505 {
506   //Computes the number of dead towers etc etc into memory, after this you can call the GetDead... -functions
507   int countTot = 0;
508   int countNew = 0;
509   int countRes = 0;
510   ofstream * fout = 0;
511   ofstream * diff = 0;
512   char name[512];//Quite a long temp buffer, just in case the filename includes a path
513   
514   if (deadMapFile) {
515     snprintf(name, 512, "%s.txt", deadMapFile);
516     fout = new ofstream(name);
517     snprintf(name, 512, "%sdiff.txt", deadMapFile);
518     diff = new ofstream(name);
519     if (!fout->is_open()) {
520       delete fout;
521       fout = 0;//Set the pointer to empty if the file was not opened
522     }
523     if (!diff->is_open()) {
524       delete diff;
525       fout = 0;//Set the pointer to empty if the file was not opened
526     }
527   }
528  
529   for (int i = 0; i < fModules; i++) {
530     if (GetPeakProfileHighGain(i)->GetEntries() > 0) { //don't care about empty histos
531       for (int j = 1; j <= fColumns; j++) {
532         for (int k = 1; k <= fRows; k++) {
533
534           if (GetPeakProfileHighGain(i)->GetBinContent(j, k) < threshold) {//It's dead
535             countTot++;//One more dead total
536             if (fout) {
537               (*fout) << i << " " 
538                       << (fRows - k) << " " 
539                       << (j-1) << " " 
540                       << "1" << " " 
541                       << "0" << endl;//Write the status to the deadmap file, if the file is open.
542             }
543             
544             if (fReference && fReference->GetPeakProfileHighGain(i)->GetBinContent(j, k) >= threshold) {
545               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kRecentlyDeceased); 
546               countNew++;//This tower wasn't dead before!
547               if (diff) {
548                 ( *diff) << i << " " 
549                          << (fRows - k) << " " 
550                          << (j - 1) << " " 
551                          << "1" << " " 
552                          << "0" << endl;//Write the status to the deadmap difference file, if the file is open.
553               }
554             } 
555             else {
556               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kDead);//This has been dead before. Nothing new         
557             }
558           } 
559           else { //It's ALIVE!!
560             //Don't bother with writing the live ones.
561             //if (fout)
562             //  (*fout) << i << " " 
563             //     << (fRows - k) << " " 
564             //     << (j - 1) << " " 
565             //     << "1" << " " 
566             //     << "1" << endl;//Write the status to the deadmap file, if the file is open.
567             if (fReference && fReference->GetPeakProfileHighGain(i)->GetBinContent(j, k) < threshold) {
568               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kResurrected);
569               countRes++; //This tower was dead before => it's a miracle! :P
570               if (diff) {
571                 (*diff) << i << " " 
572                         << (fRows - k) << " " 
573                         << (j - 1) << " " 
574                         << "1" << " " 
575                         << "1" << endl;//Write the status to the deadmap difference file, if the file is open.
576               }
577             } 
578             else {
579               ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kAlive);
580             }
581           }
582             
583         }//end for k/rows
584       }//end for j/columns
585     }//end if GetEntries >= 0
586   
587   }//end for modules
588  
589  if (fout) {
590    fout->close();
591    delete fout;
592  }
593  
594  fDeadTowers = countTot;
595  fNewDeadTowers = countNew;
596  fResurrectedTowers = countRes;
597 }
598