Create the magnetic field map in the reconstruction macros (Yuri)
[u/mrichter/AliRoot.git] / MUON / AliMUONCDB.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
16 /* $Id$ */
17
18 //-----------------------------------------------------------------------------
19 /// \class AliMUONCDB
20 ///
21 /// Helper class to experience the OCDB
22 /// It allows to generate dummy (but complete) containers for all the
23 /// calibration data types we have for tracker and trigger, and to write
24 /// them into OCDB.
25 ///
26 /// For more information, please see READMECDB
27 ///
28 // \author Laurent Aphecetche
29 //-----------------------------------------------------------------------------
30
31 #include "AliMUONCDB.h"
32
33 #include "AliMUON1DArray.h"
34 #include "AliMUON1DMap.h"
35 #include "AliMUON2DMap.h"
36 #include "AliMUON2DStoreValidator.h"
37 #include "AliMUONCalibParamNF.h"
38 #include "AliMUONCalibParamNI.h"
39 #include "AliMUONConstants.h"
40 #include "AliMUONTrackerIO.h"
41 #include "AliMUONTriggerEfficiencyCells.h"
42 #include "AliMUONTriggerLut.h"
43 #include "AliMUONVStore.h"
44 #include "AliMUONVCalibParam.h"
45 #include "AliMUONVCalibParam.h"
46
47 #include "AliMpCDB.h"
48 #include "AliMpConstants.h"
49 #include "AliMpDDLStore.h"
50 #include "AliMpDEIterator.h"
51 #include "AliMpDEManager.h"
52 #include "AliMpDetElement.h"
53 #include "AliMpHVNamer.h"
54 #include "AliMpManuIterator.h"
55 #include "AliMpSegmentation.h"
56 #include "AliMpStationType.h"
57 #include "AliMpVSegmentation.h"
58
59 #include "AliCodeTimer.h"
60 #include "AliCDBEntry.h"
61 #include "AliCDBManager.h"
62 #include "AliDCSValue.h"
63 #include "AliLog.h"
64
65 #include <Riostream.h>
66 #include <TArrayI.h>
67 #include <TClass.h>
68 #include <TH1F.h>
69 #include <TList.h>
70 #include <TMap.h>
71 #include <TObjString.h>
72 #include <TROOT.h>
73 #include <TRandom.h>
74 #include <TStopwatch.h>
75 #include <TSystem.h>
76 #include <TMath.h>
77
78
79 /// \cond CLASSIMP
80 ClassImp(AliMUONCDB)
81 /// \endcond
82
83 namespace
84 {
85   //_____________________________________________________________________________
86 AliMUONVStore* Create2DMap()
87 {
88   return new AliMUON2DMap(true);
89 }
90
91   //_____________________________________________________________________________
92 void getBoundaries(const AliMUONVStore& store, Int_t dim,
93                    Float_t* xmin, Float_t* xmax)
94 {
95   /// Assuming the store contains AliMUONVCalibParam objects, compute the
96   /// limits of the value contained in the VCalibParam, for each of its dimensions
97   /// xmin and xmax must be of dimension dim
98   
99   for ( Int_t i = 0; i < dim; ++i ) 
100   {
101     xmin[i]=1E30;
102     xmax[i]=-1E30;
103   }
104   
105   TIter next(store.CreateIterator());
106   AliMUONVCalibParam* value;
107   
108   while ( ( value = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
109   {
110     Int_t detElemId = value->ID0();
111     Int_t manuId = value->ID1();
112     
113     const AliMpVSegmentation* seg = 
114       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
115         
116     for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
117     {
118       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
119       if (!pad.IsValid()) continue;
120       
121       for ( Int_t i = 0; i < dim; ++i ) 
122       {
123         Float_t x0 = value->ValueAsFloat(manuChannel,i);
124       
125         xmin[i] = TMath::Min(xmin[i],x0);
126         xmax[i] = TMath::Max(xmax[i],x0);
127       }
128     }
129   }
130
131   for ( Int_t i = 0; i < dim; ++i ) 
132   {
133     if ( TMath::Abs(xmin[i]-xmax[i]) < 1E-3 ) 
134     {
135       xmin[i] -= 1;
136       xmax[i] += 1;
137     }
138   }
139 }
140
141 //_____________________________________________________________________________
142 Double_t GetRandom(Double_t mean, Double_t sigma, Bool_t mustBePositive)
143 {
144   Double_t x(-1);
145   if ( mustBePositive ) 
146   {
147     while ( x < 0 ) 
148     {
149       x = gRandom->Gaus(mean,sigma);
150     }
151   }
152   else
153   {
154     x = gRandom->Gaus(mean,sigma);
155   }
156   return x;
157 }
158
159 }
160
161 //_____________________________________________________________________________
162 AliMUONCDB::AliMUONCDB(const char* cdbpath)
163 : TObject(),
164   fCDBPath(cdbpath),
165   fMaxNofChannelsToGenerate(-1)
166 {
167   /// ctor
168     // Load mapping
169     if ( ! AliMpCDB::LoadDDLStore() ) {
170       AliFatal("Could not access mapping from OCDB !");
171     }
172 }
173
174 //_____________________________________________________________________________
175 AliMUONCDB::~AliMUONCDB()
176 {
177   /// dtor
178 }
179
180 //_____________________________________________________________________________
181 AliMUONVStore* 
182 AliMUONCDB::Diff(AliMUONVStore& store1, AliMUONVStore& store2, 
183                  const char* opt)
184 {
185   /// creates a store which contains store1-store2
186   /// if opt="abs" the difference is absolute one,
187   /// if opt="rel" then what is stored is (store1-store2)/store1
188   /// if opt="percent" then what is stored is rel*100
189   ///
190   /// WARNING Works only for stores which holds AliMUONVCalibParam objects
191   
192   TString sopt(opt);
193   sopt.ToUpper();
194   
195   if ( !sopt.Contains("ABS") && !sopt.Contains("REL") && !sopt.Contains("PERCENT") )
196   {
197     AliErrorClass(Form("opt %s not supported. Only ABS, REL, PERCENT are",opt));
198     return 0x0;
199   }
200   
201   AliMUONVStore* d = static_cast<AliMUONVStore*>(store1.Clone());
202   
203   TIter next(d->CreateIterator());
204   
205   AliMUONVCalibParam* param;
206   
207   while ( ( param = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
208   {
209     Int_t detElemId = param->ID0();
210     Int_t manuId = param->ID1();
211     
212     AliMUONVCalibParam* param2 = dynamic_cast<AliMUONVCalibParam*>(store2.FindObject(detElemId,manuId));
213     //FIXME: this might happen. Handle it.
214     if (!param2) 
215     {
216       cerr << "param2 is null : FIXME : this might happen !" << endl;
217       delete d;
218       return 0;
219     }
220     
221     for ( Int_t i = 0; i < param->Size(); ++i )
222     {
223       for ( Int_t j = 0; j < param->Dimension(); ++j )
224       {
225         Float_t value(0);
226         if ( sopt.Contains("ABS") )
227         {
228           value = param->ValueAsFloat(i,j) - param2->ValueAsFloat(i,j);
229         }
230         else if ( sopt.Contains("REL") || sopt.Contains("PERCENT") )
231         {
232           if ( param->ValueAsFloat(i,j) ) 
233           {
234             value = (param->ValueAsFloat(i,j) - param2->ValueAsFloat(i,j))/param->ValueAsFloat(i,j);
235           }
236           else 
237           {
238             continue;
239           }
240           if ( sopt.Contains("PERCENT") ) value *= 100.0;
241         }
242         param->SetValueAsFloat(i,j,value);
243       }      
244     }
245   }
246   return d;
247 }
248
249 //_____________________________________________________________________________
250 void 
251 AliMUONCDB::Plot(const AliMUONVStore& store, const char* name, Int_t nbins)
252 {
253   /// Make histograms of each dimension of the AliMUONVCalibParam
254   /// contained inside store.
255   /// It produces histograms named name_0, name_1, etc...
256   
257   TIter next(store.CreateIterator());
258   AliMUONVCalibParam* param;
259   Int_t n(0);
260   const Int_t kNStations = AliMpConstants::NofTrackingChambers()/2;
261   Int_t* nPerStation = new Int_t[kNStations];
262   TH1** h(0x0);
263   
264   for ( Int_t i = 0; i < kNStations; ++i ) nPerStation[i]=0;
265   
266   while ( ( param = static_cast<AliMUONVCalibParam*>(next()) ) )
267   {
268     if (!h)
269     {
270       Int_t dim = param->Dimension();
271       h = new TH1*[dim];
272       Float_t* xmin = new Float_t[dim];
273       Float_t* xmax = new Float_t[dim];
274       getBoundaries(store,dim,xmin,xmax);
275       
276       for ( Int_t i = 0; i < dim; ++i ) 
277       {
278         h[i] = new TH1F(Form("%s_%d",name,i),Form("%s_%d",name,i),
279                             nbins,xmin[i],xmax[i]);
280         AliInfo(Form("Created histogram %s",h[i]->GetName()));
281       }
282     }
283     
284     Int_t detElemId = param->ID0();
285     Int_t manuId = param->ID1();
286     Int_t station = AliMpDEManager::GetChamberId(detElemId)/2;
287     
288     const AliMpVSegmentation* seg = 
289       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
290     
291     for ( Int_t manuChannel = 0; manuChannel < param->Size(); ++manuChannel )
292     {
293       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
294       if (!pad.IsValid()) continue;
295
296       ++n;
297       ++nPerStation[station];
298       
299       for ( Int_t dim = 0; dim < param->Dimension(); ++dim ) 
300       {
301         h[dim]->Fill(param->ValueAsFloat(manuChannel,dim));
302       }
303     }
304   } 
305   
306   for ( Int_t i = 0; i < kNStations; ++i )
307   {
308     AliInfo(Form("Station %d %d ",(i+1),nPerStation[i]));
309   }
310
311   AliInfo(Form("Number of channels = %d",n));
312   
313   delete[] nPerStation;
314 }
315
316 //_____________________________________________________________________________
317 Int_t 
318 AliMUONCDB::MakeHVStore(TMap& aliasMap, Bool_t defaultValues)
319 {
320   /// Create a HV store
321   
322   AliMpHVNamer hvNamer;
323   
324   TObjArray* aliases = hvNamer.GenerateAliases();
325   
326   Int_t nSwitch(0);
327   Int_t nChannels(0);
328   
329   for ( Int_t i = 0; i < aliases->GetEntries(); ++i ) 
330   {
331     TObjString* alias = static_cast<TObjString*>(aliases->At(i));
332     TString& aliasName = alias->String();
333     if ( aliasName.Contains("sw") ) 
334     {
335       // HV Switch (St345 only)
336       TObjArray* valueSet = new TObjArray;
337       valueSet->SetOwner(kTRUE);
338       
339       Bool_t value = kTRUE;
340       
341       if (!defaultValues)
342       {
343         Float_t r = gRandom->Uniform();
344         if ( r < 0.007 ) value = kFALSE;      
345       } 
346       
347       for ( UInt_t timeStamp = 0; timeStamp < 60*3; timeStamp += 60 )
348       {
349         AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
350         valueSet->Add(dcsValue);
351       }
352       aliasMap.Add(new TObjString(*alias),valueSet);
353       ++nSwitch;
354     }
355     else
356     {
357       TObjArray* valueSet = new TObjArray;
358       valueSet->SetOwner(kTRUE);
359       for ( UInt_t timeStamp = 0; timeStamp < 60*15; timeStamp += 120 )
360       {
361         Float_t value = 1500;
362         if (!defaultValues) value = GetRandom(1750,62.5,true);
363         AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
364         valueSet->Add(dcsValue);
365       }
366       aliasMap.Add(new TObjString(*alias),valueSet);
367       ++nChannels;
368     }
369   }
370   
371   delete aliases;
372   
373   AliInfo(Form("%d HV channels and %d switches",nChannels,nSwitch));
374   
375   return nChannels+nSwitch;
376 }
377
378 //_____________________________________________________________________________
379 Int_t 
380 AliMUONCDB::MakePedestalStore(AliMUONVStore& pedestalStore, Bool_t defaultValues)
381 {
382   /// Create a pedestal store. if defaultValues=true, ped.mean=ped.sigma=1,
383   /// otherwise mean and sigma are from a gaussian (with parameters
384   /// defined below by the kPedestal* constants)
385
386   AliCodeTimerAuto("");
387   
388   Int_t nchannels(0);
389   Int_t nmanus(0);
390   
391   const Int_t kChannels(AliMpConstants::ManuNofChannels());
392   const Float_t kPedestalMeanMean(200);
393   const Float_t kPedestalMeanSigma(10);
394   const Float_t kPedestalSigmaMean(1.0);
395   const Float_t kPedestalSigmaSigma(0.2);
396
397   Int_t detElemId;
398   Int_t manuId;
399     
400   AliMpManuIterator it;
401   
402   while ( it.Next(detElemId,manuId) )
403   {
404     ++nmanus;
405
406     AliMUONVCalibParam* ped = 
407       new AliMUONCalibParamNF(2,kChannels,detElemId,manuId,AliMUONVCalibParam::InvalidFloatValue());
408
409     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
410     
411     for ( Int_t manuChannel = 0; manuChannel < kChannels; ++manuChannel )
412     {
413       if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
414       
415       ++nchannels;
416       
417       Float_t meanPedestal;
418       Float_t sigmaPedestal;
419       
420       if ( defaultValues ) 
421       {
422         meanPedestal = 0.0;
423         sigmaPedestal = 1.0;
424       }
425       else
426       {
427         Bool_t positive(kTRUE);
428         meanPedestal = 0.0;
429         while ( meanPedestal == 0.0 ) // avoid strict zero 
430         {
431           meanPedestal = GetRandom(kPedestalMeanMean,kPedestalMeanSigma,positive);
432         }
433         sigmaPedestal = GetRandom(kPedestalSigmaMean,kPedestalSigmaSigma,positive);
434       }
435       ped->SetValueAsFloat(manuChannel,0,meanPedestal);
436       ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
437       
438     }
439     Bool_t ok = pedestalStore.Add(ped);
440     if (!ok)
441     {
442       AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
443     }
444     if ( fMaxNofChannelsToGenerate > 0 && nchannels >= fMaxNofChannelsToGenerate ) break;
445   }
446   
447   AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
448   return nchannels;
449 }
450
451 //_____________________________________________________________________________
452 Int_t
453 AliMUONCDB::MakeCapacitanceStore(AliMUONVStore& capaStore, const char* file)
454 {
455   /// Read the capacitance values from file and append them to the capaStore
456   
457   return AliMUONTrackerIO::ReadCapacitances(file,capaStore);
458 }
459
460 //_____________________________________________________________________________
461 Int_t 
462 AliMUONCDB::MakeCapacitanceStore(AliMUONVStore& capaStore, Bool_t defaultValues)
463 {
464   /// Create a capacitance store. if defaultValues=true, all capa are 1.0,
465   /// otherwise they are from a gaussian with parameters defined in the
466   /// kCapa* constants below.
467
468   AliCodeTimerAuto("");
469   
470   Int_t nchannels(0);
471   Int_t nmanus(0);
472   Int_t nmanusOK(0); // manus for which we got the serial number
473     
474   const Float_t kCapaMean(0.3);
475   const Float_t kCapaSigma(0.1);
476   const Float_t kInjectionGainMean(3);
477   const Float_t kInjectionGainSigma(1);
478
479   Int_t detElemId;
480   Int_t manuId;
481   
482   AliMpManuIterator it;
483   
484   while ( it.Next(detElemId,manuId) )
485   {
486     ++nmanus;
487     
488     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId); 
489     Int_t serialNumber = de->GetManuSerialFromId(manuId);
490       
491     if ( serialNumber <= 0 ) continue;
492     
493     ++nmanusOK;
494     
495     AliMUONVCalibParam* capa = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
496     
497     if (!capa)
498     {
499       capa = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
500       Bool_t ok = capaStore.Add(capa);
501       if (!ok)
502       {
503         AliError(Form("Could not set serialNumber=%d manuId=%d",serialNumber,manuId));
504       }      
505     }
506     
507     for ( Int_t manuChannel = 0; manuChannel < capa->Size(); ++manuChannel )
508     {
509       if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
510       
511       ++nchannels;
512       
513       Float_t capaValue;
514       Float_t injectionGain;
515       
516       if ( defaultValues ) 
517       {
518         capaValue = 1.0;
519         injectionGain = 1.0;
520       }
521       else
522       {
523         capaValue = GetRandom(kCapaMean,kCapaSigma,kTRUE);
524         injectionGain = GetRandom(kInjectionGainMean,kInjectionGainSigma,kTRUE);
525       }
526       capa->SetValueAsFloat(manuChannel,0,capaValue);
527       capa->SetValueAsFloat(manuChannel,1,injectionGain);
528     }
529   }
530   
531   Float_t percent = 0;
532   if ( nmanus ) percent = 100*nmanusOK/nmanus;
533   AliInfo(Form("%5d manus with serial number (out of %5d manus = %3.0f%%)",
534                nmanusOK,nmanus,percent));
535   AliInfo(Form("%5d channels",nchannels));
536   if ( percent < 100 ) 
537   {
538     AliWarning("Did not get all serial numbers. capaStore is incomplete !!!!");
539   }
540   return nchannels;
541   
542 }
543
544 //_____________________________________________________________________________
545 Int_t 
546 AliMUONCDB::MakeGainStore(AliMUONVStore& gainStore, Bool_t defaultValues)
547 {  
548   /// Create a gain store. if defaultValues=true, all gains set so that
549   /// charge = (adc-ped)
550   ///
551   /// otherwise parameters are taken from gaussians with parameters 
552   /// defined in the k* constants below.
553   
554   AliCodeTimerAuto("");
555   
556   Int_t nchannels(0);
557   Int_t nmanus(0);
558     
559   const Int_t kSaturation(3000);
560   const Double_t kA0Mean(1.2);
561   const Double_t kA0Sigma(0.1);
562   const Double_t kA1Mean(1E-5);
563   const Double_t kA1Sigma(1E-6);
564   const Double_t kQualMean(0xFF);
565   const Double_t kQualSigma(0x10);
566   const Int_t kThresMean(1600);
567   const Int_t kThresSigma(100);
568   
569   Int_t detElemId;
570   Int_t manuId;
571   
572   AliMpManuIterator it;
573   
574   while ( it.Next(detElemId,manuId) )
575   {
576     ++nmanus;
577
578     AliMUONVCalibParam* gain = 
579       new AliMUONCalibParamNF(5,AliMpConstants::ManuNofChannels(),
580                               detElemId,
581                               manuId,
582                               AliMUONVCalibParam::InvalidFloatValue());
583
584     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
585
586     for ( Int_t manuChannel = 0; manuChannel < gain->Size(); ++manuChannel )
587     {
588       if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
589       
590       ++nchannels;
591       
592       if ( defaultValues ) 
593       {
594         gain->SetValueAsFloat(manuChannel,0,1.0);
595         gain->SetValueAsFloat(manuChannel,1,0.0);
596         gain->SetValueAsInt(manuChannel,2,4095); 
597         gain->SetValueAsInt(manuChannel,3,1);
598         gain->SetValueAsInt(manuChannel,4,kSaturation);
599       }
600       else
601       {
602         Bool_t positive(kTRUE);
603         gain->SetValueAsFloat(manuChannel,0,GetRandom(kA0Mean,kA0Sigma,positive));
604         gain->SetValueAsFloat(manuChannel,1,GetRandom(kA1Mean,kA1Sigma,!positive));
605         gain->SetValueAsInt(manuChannel,2,(Int_t)TMath::Nint(GetRandom(kThresMean,kThresSigma,positive)));
606         gain->SetValueAsInt(manuChannel,3,(Int_t)TMath::Nint(GetRandom(kQualMean,kQualSigma,positive)));
607         gain->SetValueAsInt(manuChannel,4,kSaturation);        
608       }
609       
610     }
611     Bool_t ok = gainStore.Add(gain);
612     if (!ok)
613     {
614       AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
615     }
616     if ( fMaxNofChannelsToGenerate > 0 && nchannels >= fMaxNofChannelsToGenerate ) break;
617   }
618   
619   AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
620   return nchannels;
621 }
622
623 //_____________________________________________________________________________
624 Int_t
625 AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONVStore& localBoardMasks) const
626 {
627   /// Generate local trigger masks store. All masks are set to FFFF
628   
629   AliCodeTimerAuto("");
630   
631   Int_t ngenerated(0);
632   // Generate fake mask values for 234 localboards and put that into
633   // one single container (localBoardMasks)
634   for ( Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); ++i )
635   {
636     AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,i,0,0);
637     for ( Int_t x = 0; x < 2; ++x )
638     {
639       for ( Int_t y = 0; y < 4; ++y )
640       {
641         Int_t index = x*4+y;
642         localBoard->SetValueAsInt(index,0,0xFFFF);
643         ++ngenerated;
644       }
645     }
646     localBoardMasks.Add(localBoard);
647   }
648   return ngenerated;
649 }
650
651 //_____________________________________________________________________________
652 Int_t
653 AliMUONCDB::MakeRegionalTriggerMaskStore(AliMUONVStore& rtm) const
654 {
655   /// Make a regional trigger masks store. Mask is set to FFFF for each local board (Ch.F.)
656   
657   AliCodeTimerAuto("");
658   
659   Int_t ngenerated(0);
660   for ( Int_t i = 0; i < 16; ++i )
661   {
662     AliMUONVCalibParam* regionalBoard = new AliMUONCalibParamNI(1,1,i,0,0);
663
664     regionalBoard->SetValueAsInt(0,0,0xFFFF);
665     ++ngenerated;
666       
667     rtm.Add(regionalBoard);
668   }
669   
670   return ngenerated;
671 }
672
673 //_____________________________________________________________________________
674 Int_t 
675 AliMUONCDB::MakeGlobalTriggerMaskStore(AliMUONVCalibParam& gtm) const
676 {
677   /// Make a global trigger masks store. All masks (disable) set to 0x00 for each Darc board (Ch.F.)
678   
679   AliCodeTimerAuto("");
680   
681   Int_t ngenerated(0);
682   
683   for ( Int_t j = 0; j < 2; ++j )
684   {
685     gtm.SetValueAsInt(j,0,0x00);
686     ++ngenerated;
687   }
688   return ngenerated;
689 }
690
691 //_____________________________________________________________________________
692 AliMUONTriggerLut* 
693 AliMUONCDB::MakeTriggerLUT(const char* file) const
694 {
695   /// Make a triggerlut object, from a file.
696   
697   AliCodeTimerAuto("");
698   
699   AliMUONTriggerLut* lut = new AliMUONTriggerLut;
700   lut->ReadFromFile(file);
701   return lut;
702 }
703
704 //_____________________________________________________________________________
705 AliMUONTriggerEfficiencyCells*
706 AliMUONCDB::MakeTriggerEfficiency(const char* file) const
707 {
708   /// Make a trigger efficiency object from a file.
709   
710   AliCodeTimerAuto("");
711   
712   return new AliMUONTriggerEfficiencyCells(file);
713 }
714
715 //_____________________________________________________________________________
716 void 
717 AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object, 
718                        Int_t startRun, Int_t endRun, 
719                        const char* filename)
720 {
721   /// Write a given object to OCDB
722   
723   AliCDBId id(calibpath,startRun,endRun);
724   AliCDBMetaData md;
725   md.SetAliRootVersion(gROOT->GetVersion());
726   md.SetComment(gSystem->ExpandPathName(filename));
727   md.SetResponsible("Uploaded using AliMUONCDB class");
728   AliCDBManager* man = AliCDBManager::Instance();
729   man->SetDefaultStorage(fCDBPath);
730   man->Put(object,id,&md);
731 }
732
733 //_____________________________________________________________________________
734 void 
735 AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object, 
736                        Int_t startRun, Int_t endRun, Bool_t defaultValues)
737 {
738   /// Write a given object to OCDB
739   
740   AliCDBId id(calibpath,startRun,endRun);
741   AliCDBMetaData md;
742   md.SetAliRootVersion(gROOT->GetVersion());
743   if ( defaultValues )
744   {
745     md.SetComment("Test with default values");
746   }
747   else
748   {
749     md.SetComment("Test with random values");
750   }
751   md.SetResponsible("AliMUONCDB tester class");
752   
753   AliCDBManager* man = AliCDBManager::Instance();
754   man->SetDefaultStorage(fCDBPath);
755   man->Put(object,id,&md);
756 }
757
758 //_____________________________________________________________________________
759 Int_t 
760 AliMUONCDB::MakeNeighbourStore(AliMUONVStore& neighbourStore)
761 {
762   /// Fill the neighbours store with, for each channel, a TObjArray of its
763   /// neighbouring pads (including itself)
764   
765   AliCodeTimerAuto("");
766   
767   AliInfo("Generating NeighbourStore. This will take a while. Please be patient.");
768   
769   Int_t nchannels(0);
770   
771   TObjArray tmp;
772
773   Int_t detElemId;
774   Int_t manuId;
775   
776   AliMpManuIterator it;
777   
778   while ( it.Next(detElemId,manuId) )
779   {
780     const AliMpVSegmentation* seg = 
781       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
782     
783     AliMUONVCalibParam* calibParam = static_cast<AliMUONVCalibParam*>(neighbourStore.FindObject(detElemId,manuId));
784     if (!calibParam)
785     {
786       Int_t dimension(11);
787       Int_t size(AliMpConstants::ManuNofChannels());
788       Int_t defaultValue(-1);
789       Int_t packingFactor(size);
790       
791       calibParam = new AliMUONCalibParamNI(dimension,size,detElemId,manuId,defaultValue,packingFactor);
792       Bool_t ok = neighbourStore.Add(calibParam);
793       if (!ok)
794       {
795         AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
796         return -1;
797       }      
798     }
799     
800     for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
801     {
802       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
803       
804       if (pad.IsValid()) 
805       {
806         ++nchannels;
807
808         seg->GetNeighbours(pad,tmp,true,true);
809         Int_t nofPadNeighbours = tmp.GetEntriesFast();
810             
811         for ( Int_t i = 0; i < nofPadNeighbours; ++i )
812         {
813           AliMpPad* pad = static_cast<AliMpPad*>(tmp.UncheckedAt(i));
814           Int_t x;
815 //          Bool_t ok =
816           calibParam->PackValues(pad->GetLocation().GetFirst(),pad->GetLocation().GetSecond(),x);
817 //          if (!ok)
818 //          {
819 //            AliError("Could not pack value. Something is seriously wrong. Please check");
820 //            StdoutToAliError(pad->Print(););
821 //            return -1;
822 //          }
823           calibParam->SetValueAsInt(manuChannel,i,x);
824         }
825       }
826     }
827     }
828   
829   return nchannels;
830 }
831
832 //_____________________________________________________________________________
833 void
834 AliMUONCDB::SetMaxNofChannelsToGenerate(Int_t n)
835 {
836   /// Set the maximum number of channels to generate (used for testing only)
837   /// n < 0 means no limit
838   fMaxNofChannelsToGenerate = n;
839 }
840
841 //_____________________________________________________________________________
842 void
843 AliMUONCDB::WriteLocalTriggerMasks(Int_t startRun, Int_t endRun)
844 {  
845   /// Write local trigger masks to OCDB
846   
847   AliMUONVStore* ltm = new AliMUON1DArray(235);
848   Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
849   AliInfo(Form("Ngenerated = %d",ngenerated));
850   if (ngenerated>0)
851   {
852     WriteToCDB("MUON/Calib/LocalTriggerBoardMasks",ltm,startRun,endRun,true);
853   }
854   delete ltm;
855 }
856
857 //_____________________________________________________________________________
858 void
859 AliMUONCDB::WriteRegionalTriggerMasks(Int_t startRun, Int_t endRun)
860 {  
861   /// Write regional trigger masks to OCDB
862   
863   AliMUONVStore* rtm = new AliMUON1DArray(16);
864   Int_t ngenerated = MakeRegionalTriggerMaskStore(*rtm);
865   AliInfo(Form("Ngenerated = %d",ngenerated));
866   if (ngenerated>0)
867   {
868     WriteToCDB("MUON/Calib/RegionalTriggerBoardMasks",rtm,startRun,endRun,true);
869   }
870   delete rtm;
871 }
872
873 //_____________________________________________________________________________
874 void
875 AliMUONCDB::WriteGlobalTriggerMasks(Int_t startRun, Int_t endRun)
876 {  
877   /// Write global trigger masks to OCDB
878   
879   AliMUONVCalibParam* gtm = new AliMUONCalibParamNI(1,2,1,0,0);
880
881   Int_t ngenerated = MakeGlobalTriggerMaskStore(*gtm);
882   AliInfo(Form("Ngenerated = %d",ngenerated));
883   if (ngenerated>0)
884   {
885     WriteToCDB("MUON/Calib/GlobalTriggerBoardMasks",gtm,startRun,endRun,true);
886   }
887   delete gtm;
888 }
889
890 //_____________________________________________________________________________
891 void
892 AliMUONCDB::WriteTriggerLut(Int_t startRun, Int_t endRun)
893 {  
894   /// Write trigger LUT to OCDB
895   
896   AliMUONTriggerLut* lut = MakeTriggerLUT();
897   if (lut)
898   {
899     WriteToCDB("MUON/Calib/TriggerLut",lut,startRun,endRun,true);
900   }
901   delete lut;
902 }
903
904 //_____________________________________________________________________________
905 void
906 AliMUONCDB::WriteTriggerEfficiency(Int_t startRun, Int_t endRun)
907 {  
908   /// Write trigger efficiency to OCDB
909   
910   AliMUONTriggerEfficiencyCells* eff = MakeTriggerEfficiency();
911   if (eff)
912   {
913     WriteToCDB("MUON/Calib/TriggerEfficiency",eff,startRun,endRun,true);
914   }
915   delete eff;
916 }
917
918 //_____________________________________________________________________________
919 void 
920 AliMUONCDB::WriteNeighbours(Int_t startRun, Int_t endRun)
921 {
922   /// Write neighbours to OCDB
923   
924   AliMUONVStore* neighbours = Create2DMap();
925   Int_t ngenerated = MakeNeighbourStore(*neighbours);
926   AliInfo(Form("Ngenerated = %d",ngenerated));
927   if (ngenerated>0)
928   {
929     WriteToCDB("MUON/Calib/Neighbours",neighbours,startRun,endRun,true);
930   }
931   delete neighbours;
932 }
933
934 //_____________________________________________________________________________
935 void 
936 AliMUONCDB::WriteHV(Bool_t defaultValues,
937                     Int_t startRun, Int_t endRun)
938 {
939   /// generate HV values (either cste = 1500 V) if defaultValues=true or random
940   /// if defaultValues=false, see makeHVStore) and
941   /// store them into CDB located at cdbpath, with a validity period
942   /// ranging from startRun to endRun
943   
944   TMap* hvStore = new TMap;
945   Int_t ngenerated = MakeHVStore(*hvStore,defaultValues);
946   AliInfo(Form("Ngenerated = %d",ngenerated));
947   if (ngenerated>0)
948   {
949     WriteToCDB("MUON/Calib/HV",hvStore,startRun,endRun,defaultValues);
950   }
951   delete hvStore;
952 }
953
954 //_____________________________________________________________________________
955 void 
956 AliMUONCDB::WritePedestals(Bool_t defaultValues,
957                            Int_t startRun, Int_t endRun)
958 {
959   /// generate pedestal values (either 0 if defaultValues=true or random
960   /// if defaultValues=false, see makePedestalStore) and
961   /// store them into CDB located at cdbpath, with a validity period
962   /// ranging from startRun to endRun
963   
964   AliMUONVStore* pedestalStore = Create2DMap();
965   Int_t ngenerated = MakePedestalStore(*pedestalStore,defaultValues);
966   AliInfo(Form("Ngenerated = %d",ngenerated));
967   WriteToCDB("MUON/Calib/Pedestals",pedestalStore,startRun,endRun,defaultValues);
968   delete pedestalStore;
969 }
970
971
972 //_____________________________________________________________________________
973 void 
974 AliMUONCDB::WriteGains(Bool_t defaultValues,
975                        Int_t startRun, Int_t endRun)
976 {
977   /// generate gain values (either 1 if defaultValues=true or random
978   /// if defaultValues=false, see makeGainStore) and
979   /// store them into CDB located at cdbpath, with a validity period
980   /// ranging from startRun to endRun
981   
982   AliMUONVStore* gainStore = Create2DMap();
983   Int_t ngenerated = MakeGainStore(*gainStore,defaultValues);
984   AliInfo(Form("Ngenerated = %d",ngenerated));  
985   WriteToCDB("MUON/Calib/Gains",gainStore,startRun,endRun,defaultValues);
986   delete gainStore;
987 }
988
989 //_____________________________________________________________________________
990 void 
991 AliMUONCDB::WriteCapacitances(const char* filename,
992                               Int_t startRun, Int_t endRun)
993 {
994   /// read manu capacitance and injection gain values from file 
995   /// and store them into CDB located at cdbpath, with a validity period
996   /// ranging from startRun to endRun
997   
998   AliMUONVStore* capaStore = new AliMUON1DMap(16828);
999   Int_t ngenerated = MakeCapacitanceStore(*capaStore,filename);
1000   AliInfo(Form("Ngenerated = %d",ngenerated));
1001   if ( ngenerated > 0 ) 
1002   {
1003     WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,filename);
1004   }
1005   delete capaStore;
1006 }
1007
1008 //_____________________________________________________________________________
1009 void 
1010 AliMUONCDB::WriteCapacitances(Bool_t defaultValues,
1011                               Int_t startRun, Int_t endRun)
1012 {
1013   /// generate manu capacitance values (either 1 if defaultValues=true or random
1014   /// if defaultValues=false, see makeCapacitanceStore) and
1015   /// store them into CDB located at cdbpath, with a validity period
1016   /// ranging from startRun to endRun
1017   
1018   AliMUONVStore* capaStore = new AliMUON1DMap(16828);
1019   Int_t ngenerated = MakeCapacitanceStore(*capaStore,defaultValues);
1020   AliInfo(Form("Ngenerated = %d",ngenerated));
1021   WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,defaultValues);
1022   delete capaStore;
1023 }
1024
1025 //_____________________________________________________________________________
1026 void
1027 AliMUONCDB::WriteTrigger(Int_t startRun, Int_t endRun)
1028 {
1029   /// Writes all Trigger related calibration to CDB
1030   WriteLocalTriggerMasks(startRun,endRun);
1031   WriteRegionalTriggerMasks(startRun,endRun);
1032   WriteGlobalTriggerMasks(startRun,endRun);
1033   WriteTriggerLut(startRun,endRun);
1034   WriteTriggerEfficiency(startRun,endRun);
1035 }
1036
1037 //_____________________________________________________________________________
1038 void
1039 AliMUONCDB::WriteTracker(Bool_t defaultValues, Int_t startRun, Int_t endRun)
1040 {
1041   /// Writes all Tracker related calibration to CDB
1042   WriteHV(defaultValues,startRun,endRun);
1043   WritePedestals(defaultValues,startRun,endRun);
1044   WriteGains(defaultValues,startRun,endRun);
1045   WriteCapacitances(defaultValues,startRun,endRun);
1046   WriteNeighbours(startRun,endRun);
1047 }