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