AliRoot Core  edcc906 (edcc906)
AliMUONPedestal.cxx
Go to the documentation of this file.
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 
16 // $Id$
17 
18 #include "AliMUONPedestal.h"
19 #include "AliMUONErrorCounter.h"
20 #include "AliMUONVStore.h"
21 #include "AliMUON2DMap.h"
22 #include "AliMUONCalibParamND.h"
23 #include "AliMpConstants.h"
24 #include <TString.h>
25 #include <TTimeStamp.h>
26 #include <TMath.h>
27 #include <TTree.h>
28 #include <TFile.h>
29 #include <TH1F.h>
30 #include <THashList.h>
31 #include <Riostream.h>
32 
33 #include <sstream>
34 
35 //-----------------------------------------------------------------------------
44 //-----------------------------------------------------------------------------
45 
46 using std::ostream;
47 using std::ifstream;
48 using std::endl;
49 using std::cout;
50 using std::ios;
52 ClassImp(AliMUONPedestal)
54 
55 //______________________________________________________________________________
57 : TObject(),
58 //fN(0),
59 fNCurrentEvents(0),
60 fNEvthreshold(0),
61 fSorting(0),
62 fNEvents(0),
63 fRunNumber(0),
64 fNChannel(0),
65 fNManu(0),
66 fNManuConfig(0),
67 fConfig(1),
68 fStatusDA(0),
69 fHistos(0),
70 fErrorBuspatchTable(new AliMUON2DMap(kFALSE)),
71 fManuBuspatchTable(new AliMUON2DMap(kFALSE)),
72 fManuBPoutofconfigTable(new AliMUON2DMap(kFALSE)),
73 fDate(new TTimeStamp()),
74 fFilcout(0),
75 fHistoFileName(),
76 fPedestalStore(new AliMUON2DMap(kTRUE)),
77 fIndex(-1),
78 fPrefixDA(),
79 fPrefixLDC(),
80 fHistoFile(0),
81 fTree(0)
82 {
84 }
85 //______________________________________________________________________________
86 AliMUONPedestal::AliMUONPedestal(TRootIOCtor* /*dummy*/)
87 : TObject(),
88 //fN(0),
89 fNCurrentEvents(0),
90 fNEvthreshold(0),
91 fSorting(0),
92 fNEvents(0),
93 fRunNumber(0),
94 fNChannel(0),
95 fNManu(0),
96 fNManuConfig(0),
97 fConfig(1),
98 fStatusDA(0),
99 fHistos(0),
100 fErrorBuspatchTable(0),
101 fManuBuspatchTable(0),
102 fManuBPoutofconfigTable(0),
103 fDate(0),
104 fFilcout(0),
105 fHistoFileName(),
106 fPedestalStore(0),
107 fIndex(-1),
108 fPrefixDA(),
109 fPrefixLDC(),
110 fHistoFile(0),
111 fTree(0)
112 {
114 }
115 
116 //______________________________________________________________________________
118 {
120  delete fErrorBuspatchTable;
121  delete fManuBuspatchTable;
122  delete fPedestalStore;
124 }
125 
126 //______________________________________________________________________________
127 const char*
129 {
131  return fHistoFileName.Data();
132 }
133 
134 //______________________________________________________________________________
135 void AliMUONPedestal::LoadConfig(const char* dbfile)
136 {
138 
139  Int_t manuId;
140  Int_t busPatchId;
141 
142  ifstream filein(dbfile,ios::in);
143 
144  while (!filein.eof())
145  {
146  filein >> busPatchId >> manuId;
147 
148  AliMUONVCalibParam* ped =
149  static_cast<AliMUONVCalibParam*>(fPedestalStore ->FindObject(busPatchId, manuId));
150 
151  if (!ped) {
152  fNManuConfig++;
153  fNChannel+=64;
154  ped = new AliMUONCalibParamND(2, AliMpConstants::ManuNofChannels(),busPatchId, manuId, -1.); // put default wise -1, not connected channel
155  fPedestalStore ->Add(ped);
156 
157  if ( ! fManuBuspatchTable->FindObject(busPatchId,manuId) )
158  {
159  // New (buspatch,manu)
160  AliMUONErrorCounter* manuCounter = new AliMUONErrorCounter(busPatchId,manuId);
161  fManuBuspatchTable->Add(manuCounter);
162  }
163  }
164  }
165 }
166 //______________________________________________________________________________
167 void AliMUONPedestal::MakePed(Int_t busPatchId, Int_t manuId, Int_t channelId, Int_t charge)
168 {
169  static Int_t tree_charge=0;
170  static Int_t warn=0;
171  Int_t DDL= busPatchId/100+2560;
173  AliMUONVCalibParam* ped =
174  static_cast<AliMUONVCalibParam*>(fPedestalStore ->FindObject(busPatchId, manuId));
175 
176 
177  if(!tree_charge && fHistos==2)
178  {
179  fTree = new TTree("tc","Charge tree");
180  fTree->Branch("bp",&busPatchId,"bp/I");
181  fTree->Branch("manu",&manuId,",manu/I");
182  fTree->Branch("channel",&channelId,",channel/I");
183  fTree->Branch("DDL",&DDL,",DDL/I");
184  fTree->Branch("charge",&charge,"charge/I");
185  // fTree->Branch("Pedestal",&Pedestal,"Pedestal/D");
186  // fTree->Branch("chargetrue",&chargeminusPed,"chargetrue/D");
187  // fTree->Branch("evt",&evt,"evt/I");
188  tree_charge=1;
189  }
190 
191 
192  if (!ped)
193  {
194  if(fConfig)
195  { // Fill out_of_config (buspatch,manu) table
196  if (!(static_cast<AliMUONErrorCounter*>(fManuBPoutofconfigTable->FindObject(busPatchId,manuId))))
197  fManuBPoutofconfigTable->Add(new AliMUONErrorCounter(busPatchId,manuId));
198  if(warn<10) cout << fPrefixLDC.Data() << " : !!! WARNING : busPatchId = " << busPatchId << " manuId = " << manuId << " not in the Detector configuration " << endl;
199  else if(warn==10) cout << fPrefixLDC.Data() << " : !!! see .log file for an exhaustive list of (busPatchId, manuId) out of Detector configuration \n" << endl;
200  warn++;
201  (*fFilcout) <<" !!! WARNING : busPatchId = " << busPatchId << " manuId = " << manuId << " not in the Detector configuration " << endl;
202  }
203  else {fNManu++;}
204  fNChannel+=64;
205  // put default wise -1, not connected channel
206  ped = new AliMUONCalibParamND(2, AliMpConstants::ManuNofChannels(),busPatchId, manuId, -1.);
207  fPedestalStore ->Add(ped);
208  }
209 
210  // Initialization for the first value
211  if (ped->ValueAsDouble(channelId, 0) == -1)
212  {
213  if(fConfig && channelId == 0){fNManu++;}
214  ped->SetValueAsDouble(channelId, 0, 0.);
215  }
216  if (ped->ValueAsDouble(channelId, 1) == -1) ped->SetValueAsDouble(channelId, 1, 0.);
217 
218  if(fHistos==2) fTree->Fill();
219 
220  Double_t pedMean = ped->ValueAsDouble(channelId, 0) + (Double_t) charge;
221  Double_t pedSigma = ped->ValueAsDouble(channelId, 1) + (Double_t) charge*charge;
222 
223  ped->SetValueAsDouble(channelId, 0, pedMean);
224  ped->SetValueAsDouble(channelId, 1, pedSigma);
225 
226  AliMUONErrorCounter* manuCounter;
227  if (!(manuCounter = static_cast<AliMUONErrorCounter*>(fManuBuspatchTable->FindObject(busPatchId,manuId))))
228  {
229  // New (buspatch,manu)
230  manuCounter = new AliMUONErrorCounter(busPatchId,manuId);
231  fManuBuspatchTable->Add(manuCounter);
232  }
233  else
234  {
235  // Existing buspatch
236  manuCounter->Increment();
237  }
238 }
239 //______________________________________________________________________________
241 {
243 
244  Double_t pedMean;
245  Double_t pedSigma;
246  Double_t pedSigmalimit=0.5;
247  Int_t busPatchId;
248  Int_t manuId;
249  Int_t channelId;
250  Int_t status=0;
251 
252  // print in logfile
254  {
255  cout<< "\n" << fPrefixLDC.Data() << " : See list of Buspatches with lower statistics (due to parity errors) in .log or .ped file "<<endl;
256  (*fFilcout)<<"\nWarning: Buspatches with less statistics (due to parity errors)"<<endl;
257  TIter nextParityError(fErrorBuspatchTable->CreateIterator());
258  AliMUONErrorCounter* parityerror;
259  while((parityerror = static_cast<AliMUONErrorCounter*>(nextParityError())))
260  {
261  // cout<<" bp "<<parityerror->BusPatch()<<": used events = "<<fNEvents-parityerror->Events()<<endl;
262  (*fFilcout)<<" bp "<<parityerror->BusPatch()<<": used events = "<<fNEvents-parityerror->Events()<<endl;
263  }
264  }
265 
266  Int_t nADC4090=0;
267  Int_t nADCmax=0;
268  // iterator over pedestal
269  TIter next(fPedestalStore ->CreateIterator());
270  AliMUONVCalibParam* ped;
271 
272  while ( ( ped = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
273  {
274  busPatchId = ped->ID0();
275  manuId = ped->ID1();
276  if(manuId==0)
277  {
278  cout << fPrefixLDC.Data() << " : Warning: ManuId = " << manuId << " !!! in BP = " << busPatchId << endl;
279  (*fFilcout) << "Warning: ManuId = " << manuId << " !!! in BP = " << busPatchId << endl;
280  }
281  Int_t eventCounter;
282  // Correct the number of events for buspatch with errors
283  AliMUONErrorCounter* errorCounter;
284  if ((errorCounter = (AliMUONErrorCounter*)fErrorBuspatchTable->FindObject(busPatchId)))
285  {
286  eventCounter = fNEvents - errorCounter->Events();
287  }
288  else
289  {
290  eventCounter = fNEvents;
291  }
292  Int_t occupancy=0; // channel missing in raw data or read but rejected (case of parity error)
293  // value of (buspatch, manu) occupancy
294  AliMUONErrorCounter* manuCounter;
295  manuCounter = static_cast<AliMUONErrorCounter*>(fManuBuspatchTable->FindObject(busPatchId,manuId));
296  if(eventCounter>0)occupancy = manuCounter->Events()/64/eventCounter;
297  if(occupancy>1)
298  {
299  cout << fPrefixLDC.Data() << " : Warning: ManuId = " << manuId << " !!! in BP = " << busPatchId << " occupancy (>1) = " << occupancy << endl;
300  (*fFilcout) << "Warning: ManuId = " << manuId << " !!! in BP = " << busPatchId << " occupancy (>1) = " << occupancy <<endl;
301  }
302 
303  for (channelId = 0; channelId < ped->Size() ; ++channelId)
304  {
305  pedMean = ped->ValueAsDouble(channelId, 0);
306 
307  if (pedMean >= 0) // connected channels
308  {
309  ped->SetValueAsDouble(channelId, 0, pedMean/(Double_t)eventCounter);
310  pedMean = ped->ValueAsDouble(channelId, 0);
311  pedSigma = ped->ValueAsDouble(channelId, 1);
312  ped->SetValueAsDouble(channelId, 1, TMath::Sqrt(TMath::Abs(pedSigma/(Double_t)eventCounter - pedMean*pedMean)));
313 
314  if(eventCounter < fNEvthreshold )
315  { nADCmax++; ped->SetValueAsDouble(channelId, 0, ADCMax());
316  ped->SetValueAsDouble(channelId, 1, ADCMax());}
317  if( ped->ValueAsDouble(channelId, 1) < pedSigmalimit )
318  { nADC4090++; ped->SetValueAsDouble(channelId, 0, ADCMax()-5);
319  ped->SetValueAsDouble(channelId, 1, ADCMax()-5);}
320  if(manuId == 0 || occupancy>1)
321  { nADCmax++; ped->SetValueAsDouble(channelId, 0, ADCMax());
322  ped->SetValueAsDouble(channelId, 1, ADCMax());
323  if(occupancy>1 && channelId==0)ped->SetValueAsDouble(channelId, 0, ADCMax()+occupancy);}
324  }
325  else
326  { nADCmax++; ped->SetValueAsDouble(channelId, 0, ADCMax());
327  ped->SetValueAsDouble(channelId, 1, ADCMax());}
328  }
329  }
330 
331  float frac1=0. , frac2=0. ;
332  float frac_badped = 0.25 ; // maximal acceptable ratio of bad pedestals
333  char* detail;
334 
335  if(fNChannel)
336  {
337  if(nADCmax>0)
338  { frac1 = float(nADCmax)/float(fNChannel);
339  detail=Form("%s : Warning: Nb of Channels with bad Pedestal (Ped=4095) = %d over %d (%6.2f%)",fPrefixLDC.Data(),nADCmax,fNChannel,frac1*100.);
340  printf("%s\n",detail);
341  (*fFilcout) << detail << endl;}
342 
343  if(nADC4090>0)
344  { frac2 = 1.*nADC4090/fNChannel;
345  detail=Form("%s : Warning: Nb of Channels with PedSigma<0.5 (Ped=4090) = %d over %d (%6.2f%)",fPrefixLDC.Data(),nADC4090,fNChannel,frac2*100.);
346  printf("%s\n",detail);
347  (*fFilcout) << detail << endl; }
348 
349  if (frac1+frac2 > frac_badped) { status=-1 ;
350  detail=Form("\n%s !!! ERROR : fraction of Channels with Pedestal>=4090 = %6.2f% (> %5.2f%) (status= %d) \n",fPrefixLDC.Data(),(frac1+frac2)*100.,frac_badped*100.,status);
351  //2015-02-08 (*fFilcout) << detail << endl; printf("%s",detail) ;}
352  (*fFilcout) << detail << endl; fprintf(stderr,"%s",detail) ;}
353  }
354  else { status= -1;
355  detail=Form("\n%s !!! ERROR : Nb good channel = 0 (all pedestals are forced to 4095) !!! (status= %d)\n",fPrefixLDC.Data(),status);
356  //2015-02-08 cout << detail;
357  (*fFilcout) << detail ; fprintf(stderr,"%s",detail) ; }
358 
359  SetStatusDA(status);
360 }
361 //______________________________________________________________________________
362 void AliMUONPedestal::MakeASCIIoutput(ostream& out) const
363 {
365 
366  out<<"//===========================================================================" << endl;
367  out<<"// Pedestal file calculated by "<< fPrefixDA.Data() << endl;
368  out<<"//===========================================================================" << endl;
369  out<<"// * Run : " << fRunNumber << endl;
370  out<<"// * Date : " << fDate->AsString("l") <<endl;
371  out<<"// * Statictics : " << fNEvents << endl;
372  if(fConfig)
373  out<<"// * Nb of MANUS : " << fNManuConfig << " read in the Det. config. " << endl;
374  out<<"// * Nb of MANUS : " << fNManu << " read in raw data " << endl;
375  out<<"// * Nb of MANUS : " << fNChannel/64 << " written in pedestal file " << endl;
376  out<<"// * Nb of channels: " << fNChannel << endl;
377  out<<"//"<<endl;
378  out<<"// * Below " << fNEvthreshold << " events=> Ped.&sig.=4095" << endl;
379  out<<"// * PedSigma < 0.5 => Ped.&sig.=4090" << endl;
380 
382  {
383  out<<"//"<<endl;
384  out<<"// * Buspatches with less statistics (due to parity errors)"<<endl;
385  TIter next(fErrorBuspatchTable->CreateIterator());
386  AliMUONErrorCounter* parityerror;
387  while((parityerror = static_cast<AliMUONErrorCounter*>(next())))
388  {
389  if(fNEvents-parityerror->Events()>fNEvthreshold)
390  { out<<"// BusPatch = "<<parityerror->BusPatch()<<"\t Nevents used = "<<fNEvents-parityerror->Events()<<endl; }
391  else
392  { out<<"// BusPatch = "<<parityerror->BusPatch()<<"\t Nevents used = "<<fNEvents-parityerror->Events()<< " (Ped.&sig.=4095)" << endl; }
393  }
394  }
395  Int_t writitle=0;
396  Int_t occupancy=1;
397  if(occupancy)
398  {
399  TIter next(fPedestalStore ->CreateIterator());
400  AliMUONVCalibParam* ped;
401  while ( ( ped = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
402  {
403  Int_t busPatchId = ped->ID0();
404  Int_t manuId = ped->ID1();
405  Double_t pedMean = ped->ValueAsDouble(0, 0); // check pedestal value for channelId=0
406 
407  if(pedMean>ADCMax())
408  {
409  writitle++;
410  if(writitle==1){
411  out<<"//"<<endl;
412  out<<"// * Puzzling (Buspatch,Manu) read in raw data ? (Ped.&sig.=4095)"<<endl;}
413  occupancy=TMath::Nint(pedMean-ADCMax());
414  ped->SetValueAsDouble(0, 0, ADCMax());
415  out<<"// BusPatch = "<< busPatchId <<"\t ManuId = "<< manuId << "\t occupancy = " << occupancy << endl;
416  }
417 
418  if (manuId==0 || (fConfig && static_cast<AliMUONErrorCounter*>(fManuBPoutofconfigTable->FindObject(busPatchId,manuId))))
419  {
420  writitle++;
421  if(writitle==1){
422  out<<"//"<<endl;
423  out<<"// * Puzzling (Buspatch,Manu) read in raw data ? (Ped.&sig.=4095)"<<endl;}
424  out<<"// BusPatch = "<< busPatchId <<"\t ManuId = "<< manuId << "\t missing in the mapping" << endl;
425  }
426  }
427  }
428  out<<"//"<<endl;
429  out<<"//---------------------------------------------------------------------------" << endl;
430  out<<"//---------------------------------------------------------------------------" << endl;
431  out<<"// BP MANU CH. MEAN SIGMA"<<endl;
432  out<<"//---------------------------------------------------------------------------" << endl;
433 
434  TIter next(fPedestalStore->CreateIterator());
435  AliMUONVCalibParam* ped;
436 
437  // Sorting
438  if (fSorting)
439  {
440  printf("%s : ..... sorting pedestal values .....\n",fPrefixLDC.Data());
441  THashList pedtable(100,2);
442  while ( ( ped = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
443  {
444  pedtable.Add(ped);
445  }
446  pedtable.Sort();
447  // iterator over sorted pedestal
448  TIter nextSorted(&pedtable);
449  while ( (ped = (AliMUONVCalibParam*)(nextSorted()) ) )
450  {
451  Int_t busPatchId = ped->ID0();
452  Int_t manuId = ped->ID1();
453  for ( Int_t channelId = 0; channelId < ped->Size(); ++channelId )
454  {
455  Double_t pedMean = ped->ValueAsDouble(channelId, 0);
456  Double_t pedSigma = ped->ValueAsDouble(channelId, 1);
457  out << "\t" << busPatchId << "\t" << manuId <<"\t"<< channelId << "\t" << pedMean <<"\t"<< pedSigma << endl;
458  }
459  }
460  }
461  else
462  {
463  while ( ( ped = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
464  {
465  Int_t busPatchId = ped->ID0();
466  Int_t manuId = ped->ID1();
467  for ( Int_t channelId = 0; channelId < ped->Size(); ++channelId )
468  {
469  Double_t pedMean = ped->ValueAsDouble(channelId, 0);
470  Double_t pedSigma = ped->ValueAsDouble(channelId, 1);
471  out << "\t" << busPatchId << "\t" << manuId <<"\t"<< channelId << "\t" << pedMean <<"\t"<< pedSigma << endl;
472  }
473  }
474  }
475 }
476 
477 //______________________________________________________________________________
479 {
480 // Create histo
481  fHistoFileName=Form("%s.root",fPrefixDA.Data());
482  fHistoFile = new TFile(fHistoFileName,"RECREATE","MUON Tracking pedestals");
483 }
484 //______________________________________________________________________________
486 {
488  if (fIndex>=0) return; // Pedestal run (fIndex=-1)
489 
490  Double_t pedMean;
491  Double_t pedSigma;
492  Double_t evt;
493  Int_t busPatchId;
494  Int_t manuId;
495  Int_t channelId;
496  Int_t DDL;
497 
498 // histo
499 // TFile* histoFile = 0;
500  TTree* tree = 0;
501  TH1F* pedMeanHisto = 0;
502  TH1F* pedSigmaHisto = 0;
503 
504  // fHistoFileName=Form("%s.root",fPrefixDA.Data());
505  // histoFile = new TFile(fHistoFileName,"RECREATE","MUON Tracking pedestals");
506 
507  Int_t nx = ADCMax()+1;
508  Int_t xmin = 0;
509  Int_t xmax = ADCMax();
510  pedMeanHisto = new TH1F("pedmean_allch","Pedestal mean all channels",nx,xmin,xmax);
511  pedMeanHisto->SetDirectory(fHistoFile);
512 
513  nx = 201;
514  xmin = 0;
515  xmax = 200;
516  pedSigmaHisto = new TH1F("pedsigma_allch","Pedestal sigma all channels",nx,xmin,xmax);
517  pedSigmaHisto->SetDirectory(fHistoFile);
518 
519  tree = new TTree("t","Pedestal tree");
520  tree->Branch("DDL",&DDL,",DDL/I");
521  tree->Branch("bp",&busPatchId,"bp/I");
522  tree->Branch("manu",&manuId,",manu/I");
523  tree->Branch("channel",&channelId,",channel/I");
524  tree->Branch("pedMean",&pedMean,",pedMean/D");
525  tree->Branch("pedSigma",&pedSigma,",pedSigma/D");
526  tree->Branch("nevt",&evt,",evt/D");
527 
528  // iterator over pedestal
529  TIter next(fPedestalStore ->CreateIterator());
530  AliMUONVCalibParam* ped;
531  AliMUONErrorCounter* manuCounter;
532 
533  while ( ( ped = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
534  {
535  busPatchId = ped->ID0();
536  manuId = ped->ID1();
537  DDL= busPatchId/100+2560;
538 
539  for ( channelId = 0; channelId < ped->Size(); ++channelId )
540  {
541  pedMean = ped->ValueAsDouble(channelId, 0);
542  pedSigma = ped->ValueAsDouble(channelId, 1);
543  manuCounter = static_cast<AliMUONErrorCounter*>(fManuBuspatchTable->FindObject(busPatchId,manuId));
544  evt = manuCounter->Events()/64;
545 
546  pedMeanHisto->Fill(pedMean);
547  pedSigmaHisto->Fill(pedSigma);
548  tree->Fill();
549  }
550  }
551 
552  fHistoFile->Write();
553  fHistoFile->Close();
554 
555 }
virtual TIterator * CreateIterator() const =0
Return an iterator to loop over the whole store.
printf("Chi2/npoints = %f\n", TMath::Sqrt(chi2/npoints))
AliMUONVStore * fPedestalStore
data container: (Pedmean,sigma) values for each (BP,manuId)
Int_t fNChannel
Nb of channels (pads)
TTree * fTree
Definition: MakeTreeStat.C:55
Int_t Events() const
return nb of erroneous events
TFile * fHistoFile
.root histo file
virtual ~AliMUONPedestal()
void Increment()
Increment nb of erroneous event.
virtual Int_t Size() const =0
The number of channels handled by this object.
AliMUONVStore * fManuBPoutofconfigTable
(buspatch, manu) out of config
Int_t fConfig
flag 1(0) for reading(or not) configuration ascii file
virtual Int_t GetSize() const =0
The number of objects stored.
Int_t fNEvthreshold
Nbevt threshold (pedestal calculation)
void MakeASCIIoutput(ostream &out) const
Create String to be put into file or AMORE DB.
Int_t fNEvents
Number of events.
void MakeControlHistos()
Fill Histograms.
virtual Double_t ValueAsDouble(Int_t i, Int_t j=0) const
const char * GetHistoFileName() const
return the name of DAPedestal .root file
AliMUONVStore * fErrorBuspatchTable
Table for buspatches with parity errors.
void Finalize()
Compute the pedestal data (mean, sigma)
TTree * tree
TString fPrefixDA
specific DA prefixname
TString fPrefixLDC
specific LDC prefixname
Int_t BusPatch() const
return Buspatch value
Container of calibration values for a given number of channels.
static Int_t ManuNofChannels()
Max number of channels per manu.
Int_t fSorting
sorting flag (pedestal values)
Int_t fHistos
flag for Histograms (0,1=standard, 2=ntuple with charge)
virtual Int_t ID0() const
First id of this object.
virtual Int_t ID1() const
Second id of this object (might not be required)
Implementation of AliMUONVCalibParam for tuples of double.
Int_t fNManuConfig
Nb of Manu in the current detector configuration.
Int_t fIndex
calibration run index
TTimeStamp * fDate
date
Basic implementation of AliMUONVStore container using AliMpExMap internally.
Definition: AliMUON2DMap.h:20
void LoadConfig(const char *dbfile)
load MuonTrk configuration from ascii dbfile
virtual Bool_t Add(TObject *object)=0
Add an object to the store.
Implementation of the pedestal computing.
void CreateControlHistos()
Create Histograms.
TTree * fTree
charge Tree
Int_t fNManu
Nb of Manu.
Int_t fRunNumber
run number
TString fHistoFileName
.root histo file
void MakePed(Int_t bp, Int_t manu, Int_t ch, Int_t charge)
sum pedestal values for mean and sigma determination
void SetStatusDA(Int_t ind)
set DA status (return code)
AliMUONVStore * fManuBuspatchTable
Occupancy rate for each (buspatch, manu)
Int_t ADCMax() const
virtual TObject * FindObject(const char *name) const
Find an object by name.
virtual void SetValueAsDouble(Int_t i, Int_t j, Double_t value)