[u/mrichter/AliRoot.git] / HLT / PHOS / AliHLTPHOSBaselineAnalyzer.cxx

 /**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors: Oystein Djuvsland                                     *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          * 
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

#include "AliHLTPHOSBaselineAnalyzer.h"
#include "AliHLTPHOSBase.h"
#include "AliHLTPHOSBaseline.h"
#include "AliHLTPHOSValidCellDataStruct.h"
#include "AliHLTPHOSSanityInspector.h"
#include "AliHLTPHOSConstants.h"

#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
#include "TTree.h"
#include "TClonesArray.h"
#include "TFile.h"
#include "TH1F.h"
#include "TH2F.h"

using namespace PhosHLTConst;

//ClassImp(AliHLTPHOSBaselineAnalyzer); 

AliHLTPHOSBaselineAnalyzer::AliHLTPHOSBaselineAnalyzer() : 
  AliHLTPHOSBase(),
  fSampleStart(5),
  fMaxSignal(0),
  fMaxCrazyDifference(0),	    
  fTreePtr(0),
  fSanityInspector(0)	   
{  
  fSanityInspector = new AliHLTPHOSSanityInspector();
  
  char histName[128];
  char histTitle[128];
  for(Int_t x = 0; x < N_XCOLUMNS_MOD; x++)
  {
    for(Int_t z = 0; z < N_ZROWS_MOD; z++)
    {
      for(Int_t gain = 0; gain < N_GAINS; gain++)
      { 
	sprintf(histName, "sample_value_channel_x_col_%d_z_row_%d_gain_%d", x, z, gain);
	sprintf(histTitle, "Distribution of Sample Values for Channel X: %d - Z: %d - Gain: %d", x, z, gain);
	fChannelHistogramsPtr[x][z][gain] = new TH1F(histName, histTitle, 1024, 0, 1023);
	sprintf(histName, "fixed_sample_value_channel_x_col_%d_z_row_%d_gain_%d", x, z, gain);
	sprintf(histTitle, "Distribution of Corrected Sample Values for Channel X: %d - Z: %d - Gain: %d", x, z, gain);
	fFixedChannelHistogramsPtr[x][z][gain] = new TH1F(histName, histTitle, 1024, 0, 1023);
      }
    }
  }
  
  fRMSHistogramPtr = new TH1F("RMSHist", "RMS Values for All Channels", 1023, 0, 1023);
  fRMSMapHighGainHistogramPtr = new TH2F("RMSHGMapHist", "Map of RMS Values for High Gain Channels", 64, 0, 63, 56, 0, 55);
  fRMSMapLowGainHistogramPtr = new TH2F("RMSLGMapHist", "Map of RMS Values for Low Gain Channels", 64, 0, 63, 56, 0, 55);
  
  fFixedRMSHistogramPtr = new TH1F("fixedRMSHist", "Corrected RMS Values for All Channels", 1023, 0, 1023);
  fFixedRMSMapHighGainHistogramPtr = new TH2F("fixedRMSHGMapHist", "Map of Corrected RMS Values for High Gain Channels", 64, 0, 63, 56, 0, 55);
  fFixedRMSMapLowGainHistogramPtr = new TH2F("fixedRMSLGMapHist", "Map of Corrected RMS Values for Low Gain Channels", 64, 0, 63, 56, 0, 55);
  
  ResetBaselines();
  ResetAccumulatedBaselines();
} 

AliHLTPHOSBaselineAnalyzer::~AliHLTPHOSBaselineAnalyzer() 
{ 
} 


void
AliHLTPHOSBaselineAnalyzer::CalculateRcuBaselines(AliHLTPHOSRcuCellEnergyDataStruct* rcuData)
{
  Int_t xOff = rcuData->fRcuX * N_XCOLUMNS_RCU;
  Int_t zOff = rcuData->fRcuZ * N_ZROWS_RCU;
  Float_t baseline = 0;

  AliHLTPHOSValidCellDataStruct *data = rcuData->fValidData;

  for(Int_t i = 0; i < rcuData->fCnt; i++)
    {
      baseline = CalculateChannelBaseline(&(data[i]), xOff, zOff);
      if(!(baseline < 0))
      {
	CalculateAccumulatedChannelBaseline(data[i].fX + xOff, data[i].fZ + zOff, data[i].fGain, baseline);
      }
    }
}
  

Float_t
AliHLTPHOSBaselineAnalyzer::CalculateChannelBaseline(AliHLTPHOSValidCellDataStruct *cellData, Int_t xOff, Int_t zOff) 
{ 
  Int_t crazyness = 0;
  Int_t total = 0;
  Int_t *data = cellData->fData;
  for(Int_t i = fSampleStart; i < fNSamples; i++)
  { 
    /*
    if(cellData->fGain == 0)
    {
      fChannelLowGainHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff]->Fill(data[i]);
    }
    else
    {
      fChannelHighGainHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff]->Fill(data[i]);
    }
    */
    fChannelHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff][cellData->fGain]->Fill(data[i]);
  }
  
  if(cellData->fCrazyness == 0)
  {
       crazyness = fSanityInspector->CheckAndHealInsanity(data, fNSamples);
  }
  if(crazyness < 0)
    return crazyness;
  
  for(Int_t j = fSampleStart; j < fNSamples; j++)
    {
      if(data[j] > fMaxSignal)
	return -data[j];
    
      fFixedChannelHistogramsPtr[cellData->fX + xOff][cellData->fZ + zOff][cellData->fGain]->Fill(data[j]);
      total += data[j];
    }
  fBaselines[cellData->fX + xOff][cellData->fZ + zOff][cellData->fGain] = (float)total / (fNSamples - fSampleStart);
    
  return (float)total/(fNSamples - fSampleStart);
}
void 
AliHLTPHOSBaselineAnalyzer::CalculateAccumulatedChannelBaseline(Int_t x, Int_t z, Int_t gain, Float_t baseline)
{
  Float_t oldBaseline = fAccumulatedBaselines[x][z][gain][0];
  Float_t nEntries = fAccumulatedBaselines[x][z][gain][1];
  
  Float_t total = nEntries * oldBaseline + baseline;
  nEntries++;
  fAccumulatedBaselines[x][z][gain][0] = total / nEntries;
  fAccumulatedBaselines[x][z][gain][1] = nEntries;
}

void
AliHLTPHOSBaselineAnalyzer::CalculateChannelsBaselineRMS()
{
  for(Int_t x = 0; x < N_XCOLUMNS_MOD; x++)
  {
    for(Int_t z = 0; z < N_ZROWS_MOD; z++)
    {
      for(Int_t gain = 0; gain < N_GAINS; gain++)
      {
	fRMSHistogramPtr->Fill(fChannelHistogramsPtr[x][z][gain]->GetRMS());  
	if(gain == 1)
	  fRMSMapHighGainHistogramPtr->SetBinContent(x, z, fChannelHistogramsPtr[x][z][gain]->GetRMS());
	else
	  fRMSMapLowGainHistogramPtr->SetBinContent(x, z, fChannelHistogramsPtr[x][z][gain]->GetRMS());
		   
	fFixedRMSHistogramPtr->Fill(fFixedChannelHistogramsPtr[x][z][gain]->GetRMS());  
	if(gain == 1)
	  fFixedRMSMapHighGainHistogramPtr->SetBinContent(x, z, fFixedChannelHistogramsPtr[x][z][gain]->GetRMS());
	else
	  fFixedRMSMapLowGainHistogramPtr->SetBinContent(x, z, fFixedChannelHistogramsPtr[x][z][gain]->GetRMS());
      }
    }
  }
}    
 

void 
AliHLTPHOSBaselineAnalyzer::SetRootObjects(TTree *tree, TClonesArray *baselineArray)
{
  fTreePtr = tree;
  fBaselineArrayPtr = baselineArray;
  tree->Branch("Baselines", &fBaselineArrayPtr);
}
  

void
AliHLTPHOSBaselineAnalyzer::FillTree()
{
  AliHLTPHOSBaseline *baseline;
  Int_t n = 0;

  for(Int_t x = 0; x < N_XCOLUMNS_MOD; x++)
    {
      for(Int_t z = 0; z < N_ZROWS_MOD; z++)
	{
	  for(Int_t gain = 0; gain < N_GAINS; gain++)
	    {
	      baseline = (AliHLTPHOSBaseline*)fBaselineArrayPtr->New(n);
	      baseline->SetX(x);
	      baseline->SetZ(z);
	      baseline->SetGain(gain);
	      baseline->SetBaseline(fAccumulatedBaselines[x][z][gain][0]);
	      baseline->SetEntries((Int_t)fAccumulatedBaselines[x][z][gain][1]);
	      n++;
	    }
	}
    }
  fTreePtr->Fill();
  fBaselineArrayPtr->Clear();
}

void
AliHLTPHOSBaselineAnalyzer::WriteAccumulatedBaselines(const Char_t* filename)
{
  TFile *baselineFile = TFile::Open(filename, "recreate");
  fTreePtr->Write();
  baselineFile->Close();
}

void 
AliHLTPHOSBaselineAnalyzer::WriteChannelHistograms(const Char_t* filename)
{
  TFile *file = TFile::Open(filename, "recreate");
  
  for(Int_t x = 0; x < N_XCOLUMNS_MOD; x++)
  {
    for(Int_t z = 0; z < N_ZROWS_MOD; z++)
    {
      for(Int_t gain = 0; gain < N_GAINS; gain++)
      {
	fChannelHistogramsPtr[x][z][gain]->Write();
      }
    }
  }
  file->Close();
}


void
AliHLTPHOSBaselineAnalyzer::WriteRMSHistogram(const Char_t* filename)
{
  TFile *file = TFile::Open(filename, "recreate");
  fRMSHistogramPtr->Write();
  fRMSMapHighGainHistogramPtr->Write();
  fRMSMapLowGainHistogramPtr->Write();

  fFixedRMSHistogramPtr->Write();
  fFixedRMSMapHighGainHistogramPtr->Write();
  fFixedRMSMapLowGainHistogramPtr->Write();
  
  file->Close();
}

void 
AliHLTPHOSBaselineAnalyzer::ResetBaselines()
{
   for(Int_t x = 0; x < N_XCOLUMNS_MOD; x++)
    {
      for(Int_t z = 0; z < N_ZROWS_MOD; z++)
	{
	  for(Int_t gain = 0; gain < N_GAINS; gain++)
	    {
	      fBaselines[x][z][gain] = 0;    
	    }
	}
    }
}

void 
AliHLTPHOSBaselineAnalyzer::ResetChannelCount()
{
  fChannelCount = 0;
}
    
void 
AliHLTPHOSBaselineAnalyzer::ResetAccumulatedBaselines()
{
   for(Int_t x = 0; x < N_XCOLUMNS_MOD; x++)
    {
      for(Int_t z = 0; z < N_ZROWS_MOD; z++)
	{
	  for(Int_t gain = 0; gain < N_GAINS; gain++)
	    {
	     fAccumulatedBaselines[x][z][gain][0] = 0;
	     fAccumulatedBaselines[x][z][gain][1] = 0;
	    }
	}
    }
}

void 
AliHLTPHOSBaselineAnalyzer::SetMaxCrazyDifference(Int_t diff)
{
  fMaxCrazyDifference = diff;  
  fSanityInspector->SetMaxDifference(diff);
}


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