HLT/PHOS/AliHLTPHOSBaselineAnalyzer.cxx

   1  /**************************************************************************
   2  * This file is property of and copyright by the ALICE HLT Project        *
   3  * All rights reserved.                                                   *
   4  *                                                                        *
   5  * Primary Authors: Oystein Djuvsland                                     *
   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
  16 #include "AliHLTPHOSBaselineAnalyzer.h"
  17 #include "AliHLTPHOSBase.h"
  18 #include "AliHLTPHOSBaseline.h"
  19 #include "AliHLTPHOSValidCellDataStruct.h"
  20 #include "AliHLTPHOSSanityInspector.h"
  21 #include "AliHLTPHOSConstants.h"
  22
  23 #include "AliHLTPHOSRcuCellEnergyDataStruct.h"
  24 #include "TTree.h"
  25 #include "TClonesArray.h"
  26 #include "TFile.h"
  27 #include "TH1F.h"
  28 #include "TH2F.h"
  29
  30 using namespace PhosHLTConst;
  31
  32 ClassImp(AliHLTPHOSBaselineAnalyzer);
  33
  34 AliHLTPHOSBaselineAnalyzer::AliHLTPHOSBaselineAnalyzer() :
  35   AliHLTPHOSBase(),
  36   fSampleStart(5),
  37   fMaxCrazyDifference(0),
  38   fMaxSignal(0),
  39   fTreePtr(0),
  40   fSanityInspector(0)
  41 {
  42   //comment
  43   fSanityInspector = new AliHLTPHOSSanityInspector();
  44
  45   char histName[128];
  46   char histTitle[128];
  47   for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
  48   {
  49     for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
  50     {
  51       for(UInt_t gain = 0; gain < N_GAINS; gain++)
  52       {
  53         sprintf(histName, "sample_value_channel_x_col_%d_z_row_%d_gain_%d", x, z, gain);
  54         sprintf(histTitle, "Distribution of Sample Values for Channel X: %d - Z: %d - Gain: %d", x, z, gain);
  55         fChannelHistogramsPtr[x][z][gain] = new TH1F(histName, histTitle, 1024, 0, 1023);
  56         sprintf(histName, "fixed_sample_value_channel_x_col_%d_z_row_%d_gain_%d", x, z, gain);
  57         sprintf(histTitle, "Distribution of Corrected Sample Values for Channel X: %d - Z: %d - Gain: %d", x, z, gain);
  58         fFixedChannelHistogramsPtr[x][z][gain] = new TH1F(histName, histTitle, 1024, 0, 1023);
  59       }
  60     }
  61   }
  62
  63   fRMSHistogramPtr = new TH1F("RMSHist", "RMS Values for All Channels", 1023, 0, 1023);
  64   fRMSMapHighGainHistogramPtr = new TH2F("RMSHGMapHist", "Map of RMS Values for High Gain Channels", 64, 0, 63, 56, 0, 55);
  65   fRMSMapLowGainHistogramPtr = new TH2F("RMSLGMapHist", "Map of RMS Values for Low Gain Channels", 64, 0, 63, 56, 0, 55);
  66
  67   fFixedRMSHistogramPtr = new TH1F("fixedRMSHist", "Corrected RMS Values for All Channels", 1023, 0, 1023);
  68   fFixedRMSMapHighGainHistogramPtr = new TH2F("fixedRMSHGMapHist", "Map of Corrected RMS Values for High Gain Channels", 64, 0, 63, 56, 0, 55);
  69   fFixedRMSMapLowGainHistogramPtr = new TH2F("fixedRMSLGMapHist", "Map of Corrected RMS Values for Low Gain Channels", 64, 0, 63, 56, 0, 55);
  70
  71   ResetBaselines();
  72   ResetAccumulatedBaselines();
  73 }
  74
  75 AliHLTPHOSBaselineAnalyzer::~AliHLTPHOSBaselineAnalyzer()
  76 {
  77   //comment
  78 }
  79
  80
  81 void
  82 AliHLTPHOSBaselineAnalyzer::CalculateRcuBaselines(AliHLTPHOSRcuCellEnergyDataStruct* rcuData)
  83 {
  84   //comment
  85   Int_t xOff = rcuData->fRcuX * N_XCOLUMNS_RCU;
  86   Int_t zOff = rcuData->fRcuZ * N_ZROWS_RCU;
  87   Float_t baseline = 0;
  88
  89   AliHLTPHOSValidCellDataStruct *data = rcuData->fValidData;
  90
  91   for(Int_t i = 0; i < rcuData->fCnt; i++)
  92     {
  93       baseline = CalculateChannelBaseline(&(data[i]), xOff, zOff);
  94       if(!(baseline < 0))
  95       {
  96         CalculateAccumulatedChannelBaseline(data[i].fX + xOff, data[i].fZ + zOff, data[i].fGain, baseline);
  97       }
  98     }
  99 }
 100
 101
 102
 103 Float_t
 104 AliHLTPHOSBaselineAnalyzer::CalculateChannelBaseline(AliHLTPHOSValidCellDataStruct *cellData, Int_t xOff, Int_t zOff)
 105 {
 106   //comment
 107   Int_t crazyness = 0;
 108   Int_t total = 0;
 109   Int_t *data = cellData->fData;
 110   for(Int_t i = fSampleStart; i < fNSamples; i++)
 111   {
 112     /*
 113     if(cellData->fGain == 0)
 114     {
 115       fChannelLowGainHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff]->Fill(data[i]);
 116     }
 117     else
 118     {
 119       fChannelHighGainHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff]->Fill(data[i]);
 120     }
 121     */
 122     fChannelHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff][cellData->fGain]->Fill(data[i]);
 123   }
 124
 125   if(cellData->fCrazyness == 0)
 126   {
 127        crazyness = fSanityInspector->CheckAndHealInsanity(data, fNSamples);
 128   }
 129   if(crazyness < 0)
 130     return crazyness;
 131
 132   for(Int_t j = fSampleStart; j < fNSamples; j++)
 133     {
 134       if(data[j] > fMaxSignal)
 135         return -data[j];
 136
 137       fFixedChannelHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff][cellData->fGain]->Fill(data[j]);
 138       total += data[j];
 139     }
 140   fBaselines[cellData->fX + xOff][cellData->fZ + zOff][cellData->fGain] = (float)total / (fNSamples - fSampleStart);
 141
 142   return (float)total/(fNSamples - fSampleStart);
 143 }
 144
 145 void
 146 AliHLTPHOSBaselineAnalyzer::CalculateAccumulatedChannelBaseline(Int_t x, Int_t z, Int_t gain, Float_t baseline)
 147 {
 148   //comment
 149   Float_t oldBaseline = fAccumulatedBaselines[x][z][gain][0];
 150   Float_t nEntries = fAccumulatedBaselines[x][z][gain][1];
 151
 152   Float_t total = nEntries * oldBaseline + baseline;
 153   nEntries++;
 154   fAccumulatedBaselines[x][z][gain][0] = total / nEntries;
 155   fAccumulatedBaselines[x][z][gain][1] = nEntries;
 156 }
 157
 158 void
 159 AliHLTPHOSBaselineAnalyzer::CalculateChannelsBaselineRMS()
 160 {
 161   //comment
 162   for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
 163   {
 164     for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
 165     {
 166       for(UInt_t gain = 0; gain < N_GAINS; gain++)
 167       {
 168         fRMSHistogramPtr->Fill(fChannelHistogramsPtr[x][z][gain]->GetRMS());
 169         if(gain == 1)
 170           fRMSMapHighGainHistogramPtr->SetBinContent(x, z, fChannelHistogramsPtr[x][z][gain]->GetRMS());
 171         else
 172           fRMSMapLowGainHistogramPtr->SetBinContent(x, z, fChannelHistogramsPtr[x][z][gain]->GetRMS());
 173
 174         fFixedRMSHistogramPtr->Fill(fFixedChannelHistogramsPtr[x][z][gain]->GetRMS());
 175         if(gain == 1)
 176           fFixedRMSMapHighGainHistogramPtr->SetBinContent(x, z, fFixedChannelHistogramsPtr[x][z][gain]->GetRMS());
 177         else
 178           fFixedRMSMapLowGainHistogramPtr->SetBinContent(x, z, fFixedChannelHistogramsPtr[x][z][gain]->GetRMS());
 179       }
 180     }
 181   }
 182 }
 183
 184
 185 void
 186 AliHLTPHOSBaselineAnalyzer::SetRootObjects(TTree *tree, TClonesArray *baselineArray)
 187 {
 188   //comment
 189   fTreePtr = tree;
 190   fBaselineArrayPtr = baselineArray;
 191   tree->Branch("Baselines", &fBaselineArrayPtr);
 192 }
 193
 194
 195 void
 196 AliHLTPHOSBaselineAnalyzer::FillTree()
 197 {
 198   //comment
 199   AliHLTPHOSBaseline *baseline;
 200   Int_t n = 0;
 201
 202   for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
 203     {
 204       for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
 205         {
 206           for(UInt_t gain = 0; gain < N_GAINS; gain++)
 207             {
 208               baseline = (AliHLTPHOSBaseline*)fBaselineArrayPtr->New(n);
 209               baseline->SetX(x);
 210               baseline->SetZ(z);
 211               baseline->SetGain(gain);
 212               baseline->SetBaseline(fAccumulatedBaselines[x][z][gain][0]);
 213               baseline->SetEntries((Int_t)fAccumulatedBaselines[x][z][gain][1]);
 214               n++;
 215             }
 216         }
 217     }
 218   fTreePtr->Fill();
 219   fBaselineArrayPtr->Clear();
 220 }
 221
 222 void
 223 AliHLTPHOSBaselineAnalyzer::WriteAccumulatedBaselines(const Char_t* filename)
 224 {
 225   //comment
 226   TFile *baselineFile = TFile::Open(filename, "recreate");
 227   fTreePtr->Write();
 228   baselineFile->Close();
 229 }
 230
 231 void
 232 AliHLTPHOSBaselineAnalyzer::WriteChannelHistograms(const Char_t* filename)
 233 {
 234   //comment
 235   TFile *file = TFile::Open(filename, "recreate");
 236
 237   for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
 238   {
 239     for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
 240     {
 241       for(UInt_t gain = 0; gain < N_GAINS; gain++)
 242       {
 243         fChannelHistogramsPtr[x][z][gain]->Write();
 244       }
 245     }
 246   }
 247   file->Close();
 248 }
 249
 250
 251 void
 252 AliHLTPHOSBaselineAnalyzer::WriteRMSHistogram(const Char_t* filename)
 253 {
 254   //comment
 255   TFile *file = TFile::Open(filename, "recreate");
 256   fRMSHistogramPtr->Write();
 257   fRMSMapHighGainHistogramPtr->Write();
 258   fRMSMapLowGainHistogramPtr->Write();
 259
 260   fFixedRMSHistogramPtr->Write();
 261   fFixedRMSMapHighGainHistogramPtr->Write();
 262   fFixedRMSMapLowGainHistogramPtr->Write();
 263
 264   file->Close();
 265 }
 266
 267 void
 268 AliHLTPHOSBaselineAnalyzer::ResetBaselines()
 269 {
 270   //comment
 271    for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
 272     {
 273       for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
 274         {
 275           for(UInt_t gain = 0; gain < N_GAINS; gain++)
 276             {
 277               fBaselines[x][z][gain] = 0;
 278             }
 279         }
 280     }
 281 }
 282
 283 void
 284 AliHLTPHOSBaselineAnalyzer::ResetChannelCount()
 285 {
 286   //comment
 287   fChannelCount = 0;
 288 }
 289
 290 void
 291 AliHLTPHOSBaselineAnalyzer::ResetAccumulatedBaselines()
 292 {
 293    for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
 294     {
 295       for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
 296         {
 297           for(UInt_t gain = 0; gain < N_GAINS; gain++)
 298             {
 299              fAccumulatedBaselines[x][z][gain][0] = 0;
 300              fAccumulatedBaselines[x][z][gain][1] = 0;
 301             }
 302         }
 303     }
 304 }
 305
 306 void
 307 AliHLTPHOSBaselineAnalyzer::SetMaxCrazyDifference(Int_t diff)
 308 {
 309   //comment
 310   fMaxCrazyDifference = diff;
 311   fSanityInspector->SetMaxDifference(diff);
 312 }
 313
 314
 315
 316 /*
 317 void
 318 AliHLTPHOSBaselineAnalyzer::SetChannelsHistograms(TH1F *channelLowGainHistArray[N_XCOLUMNS_MOD][N_ZROWS_MOD], TH1F *channelHighGainHistArray[N_XCOLUMNS_MOD][N_ZROWS_MOD])
 319 {
 320   for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
 321   {
 322     for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
 323     {
 324       for(UInt_t gain = 0; gain < N_GAINS; gain++)
 325       {
 326         fChannelLowGainHistogramsPtr[x][z][gain] = channelLowGainHistArray[x][z][gain];
 327         fChannelHighGainHistogramsPtr[x][z][gain] = channelHighGainHistArray[x][z][gain];
 328       }
 329     }
 330   }
 331 }
 332 */