1336eb49b2c53141146f7cf127a908c842105695
[u/mrichter/AliRoot.git] / MUON / MUONCDB.C
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 /// By Laurent Aphecetche
19
20 #if !defined(__CINT__) || defined(__MAKECINT__)
21
22 #include "MUONCDB.h"
23
24 #include "AliCDBEntry.h"
25 #include "AliCDBManager.h"
26 #include "AliDCSValue.h"
27 #include "AliMUON1DArray.h"
28 #include "AliMUON2DMap.h"
29 #include "AliMUON2DStoreValidator.h"
30 #include "AliMUONCalibParam1I.h"
31 #include "AliMUONCalibParamNF.h"
32 #include "AliMUONConstants.h"
33 #include "AliMUONHVNamer.h"
34 #include "AliMUONObjectPair.h"
35 #include "AliMUONTriggerEfficiencyCells.h"
36 #include "AliMUONTriggerLut.h"
37 #include "AliMUONV2DStore.h"
38 #include "AliMUONVCalibParam.h"
39 #include "AliMUONVCalibParam.h"
40 #include "AliMUONVDataIterator.h"
41 #include "AliMpDEIterator.h"
42 #include "AliMpDEManager.h"
43 #include "AliMpManuList.h"
44 #include "AliMpSegmentation.h"
45 #include "AliMpStationType.h"
46 #include "AliMpVSegmentation.h"
47 #include "Riostream.h"
48 #include "TArrayI.h"
49 #include "TH1F.h"
50 #include "TList.h"
51 #include "TMap.h"
52 #include "TObjString.h"
53 #include "TRandom.h"
54 #include "TStopwatch.h"
55 #include "TSystem.h"
56 #include "TROOT.h"
57 #include <map>
58
59 #endif
60
61 //_____________________________________________________________________________
62 AliMUONV2DStore* diff(AliMUONV2DStore& store1, AliMUONV2DStore& store2, 
63                       const char* /* opt */)
64 {
65   // creates a store which contains store1-store2
66   // if opt="abs" the difference is absolute one,
67   // if opt="rel" then what is stored is (store1-store2)/store1
68   
69   AliMUONV2DStore* d = static_cast<AliMUONV2DStore*>(store1.Clone());
70
71   AliMUONVDataIterator* it = d->Iterator();
72   
73   AliMUONObjectPair* p;
74   
75   while ( ( p = dynamic_cast<AliMUONObjectPair*>(it->Next() ) ) )
76   {
77     AliMpIntPair* dm = dynamic_cast<AliMpIntPair*>(p->Key());
78     //FIXME: this might happen (if a full manu is missing, for instance)
79     //handle it.
80     assert(dm!=0);
81     AliMUONVCalibParam* param = dynamic_cast<AliMUONVCalibParam*>(p->Value());
82     //FIXMENOT: this should *not* happen
83     assert(param!=0);
84
85     AliMUONVCalibParam* param2 = dynamic_cast<AliMUONVCalibParam*>(store2.Get(dm->GetFirst(),dm->GetSecond()));
86     //FIXME: this might happen. Handle it.
87     assert(param2!=0);
88     
89     for ( Int_t i = 0; i < param->Size(); ++i )
90     {
91       for ( Int_t j = 0; j < param->Dimension(); ++j )
92       {
93         param->SetValueAsFloat(i,j,param->ValueAsFloat(i,j) - param2->ValueAsFloat(i,j));
94       }      
95     }
96   }
97   return d;
98 }
99
100 //_____________________________________________________________________________
101 void getBoundaries(const AliMUONV2DStore& store,
102                    Float_t& x0min, Float_t& x0max,
103                    Float_t& x1min, Float_t& x1max)
104 {
105   x0min=1E30;
106   x0max=-1E30;
107   x1min=1E30;
108   x1max=-1E30;
109   
110   TList* list = AliMpManuList::ManuList();
111   TIter next(list);
112   AliMpIntPair* p;
113   
114   while ( ( p = (AliMpIntPair*)next() ) )
115   {
116     Int_t detElemId = p->GetFirst();
117     Int_t manuId = p->GetSecond();
118         
119     const AliMpVSegmentation* seg = 
120       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
121           
122     AliMUONVCalibParam* value = 
123       dynamic_cast<AliMUONVCalibParam*>(store.Get(detElemId,manuId));
124     
125     if (!value) continue;
126
127     for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
128     {
129       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
130       if (!pad.IsValid()) continue;
131
132       Float_t x0 = value->ValueAsFloat(manuChannel,0);
133       
134       x0min = TMath::Min(x0min,x0);
135       x0max = TMath::Max(x0max,x0);
136       if ( value->Dimension()>1 )
137       {
138         Float_t x1 = value->ValueAsFloat(manuChannel,1);
139         x1min = TMath::Min(x1min,x1);
140         x1max = TMath::Max(x1max,x1);
141       }
142     }
143   }  
144   delete list;
145 }
146
147 //_____________________________________________________________________________
148 void plot(const AliMUONV2DStore& store, const char* name, Int_t nbins)
149 {
150   Float_t x0min, x0max, x1min, x1max;
151   
152   getBoundaries(store,x0min,x0max,x1min,x1max);
153   
154   if ( x0min > x0max ) 
155   {
156     cerr << Form("Something is wrong with boundaries : x0(min,max)=%e,%e",
157                  x0min,x0max) << endl;
158     return;
159   }
160
161   if ( TMath::Abs(x0min-x0max) < 1E-3 ) 
162   {
163     x0min -= 1;
164     x0max += 1;
165   }
166   
167   TH1* h0 = new TH1F(Form("%s_0",name),Form("%s_0",name),
168                     nbins,x0min,x0max);
169   
170   TH1* h1(0);
171   
172   if ( x1max > x1min )
173   {
174     h1 = new TH1F(Form("%s_1",name),Form("%s_1",name),
175                   nbins,x1min,x1max);
176   }
177   
178   TList* list = AliMpManuList::ManuList();
179   TIter next(list);
180   AliMpIntPair* p;
181   Int_t n(0);
182   Int_t nPerStation[7];
183   
184   for ( Int_t i = 0; i < 7; ++i ) nPerStation[i]=0;
185   
186   while ( ( p = (AliMpIntPair*)next() ) )
187   {
188     Int_t detElemId = p->GetFirst();
189     Int_t manuId = p->GetSecond();
190     Int_t station = AliMpDEManager::GetChamberId(detElemId);
191     
192     const AliMpVSegmentation* seg = 
193       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
194     
195     AliMUONVCalibParam* value = 
196       dynamic_cast<AliMUONVCalibParam*>(store.Get(detElemId,manuId));
197     
198     if (value)
199     {
200       for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
201       {
202         AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
203         if (!pad.IsValid()) continue;
204
205         ++n;
206         ++nPerStation[station];
207         Float_t x = value->ValueAsFloat(manuChannel,0);
208         if ( x>1E4 ) 
209         {
210           cout << Form("DE %d Manu %d Ch %d x=%e",detElemId,manuId,manuChannel,x)
211           << endl;
212         }
213         h0->Fill(x);
214         if (h1)
215         {
216           h1->Fill(value->ValueAsFloat(manuChannel,1));
217         }
218       }
219     }
220     else
221     {
222       cout << "Got a null value for DE=" << detElemId << " manuId="
223       << manuId << endl;
224     }
225   }
226   
227   cout << "Number of channels = " << n << endl;
228   for ( Int_t i = 0; i < 7; ++i )
229   {
230     cout << "Station " << (i+1) << " " << nPerStation[i] << endl;
231   }
232   
233   delete list;
234 }
235
236 //_____________________________________________________________________________
237 void testReadStore(const AliMUONV2DStore& store, Int_t n)
238 {
239   TList* list = AliMpManuList::ManuList();
240   TIter next(list);
241   AliMpIntPair* p;
242   
243   while ( ( p = (AliMpIntPair*)next() ) )
244   {
245     for ( Int_t i = 0; i < n; ++i )
246     {
247       store.Get(p->GetFirst(),p->GetSecond());
248     }
249   }
250   delete list;
251
252
253 //_____________________________________________________________________________
254 Int_t makeHVStore(TMap& aliasMap, Bool_t defaultValues)
255 {
256   AliMUONHVNamer hvNamer;
257   TRandom random;
258   
259   TObjArray* aliases = hvNamer.GenerateAliases();
260   
261   Int_t nSwitch(0);
262   Int_t nChannels(0);
263   
264   for ( Int_t i = 0; i < aliases->GetEntries(); ++i ) 
265   {
266     TObjString* alias = static_cast<TObjString*>(aliases->At(i));
267     TString& aliasName = alias->String();
268     if ( aliasName.Contains("sw") ) 
269     {
270       // HV Switch (St345 only)
271       TObjArray* valueSet = new TObjArray;
272       valueSet->SetOwner(kTRUE);
273       
274       Bool_t value = kTRUE;
275       
276       if (!defaultValues)
277       {
278         Float_t r = random.Uniform();
279         if ( r < 0.007 ) value = kFALSE;      
280       } 
281       
282       for ( UInt_t timeStamp = 0; timeStamp < 60*3; timeStamp += 60 )
283       {
284         AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
285         valueSet->Add(dcsValue);
286       }
287       aliasMap.Add(new TObjString(*alias),valueSet);
288       ++nSwitch;
289     }
290     else
291     {
292       TObjArray* valueSet = new TObjArray;
293       valueSet->SetOwner(kTRUE);
294       for ( UInt_t timeStamp = 0; timeStamp < 60*15; timeStamp += 120 )
295       {
296         Float_t value = 1500;
297         if (!defaultValues) value = random.Gaus(1750,62.5);
298         AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
299         valueSet->Add(dcsValue);
300       }
301       aliasMap.Add(new TObjString(*alias),valueSet);
302       ++nChannels;
303     }
304   }
305   
306   delete aliases;
307   
308   cout << nChannels << " HV channels and " << nSwitch << " switches" << endl;
309   
310   return nChannels+nSwitch;
311 }
312
313 //_____________________________________________________________________________
314 Int_t makePedestalStore(AliMUONV2DStore& pedestalStore, Bool_t defaultValues)
315 {
316   TList* list = AliMpManuList::ManuList();
317   TIter next(list);
318   
319   AliMpIntPair* p;
320   
321   Int_t nchannels(0);
322   Int_t nmanus(0);
323   
324   Bool_t replace = kFALSE;
325   
326   const Int_t nChannels(64);
327   const Float_t kPedestalMeanMean(150);
328   const Float_t kPedestalMeanSigma(10);
329   const Float_t kPedestalSigmaMean(1.0);
330   const Float_t kPedestalSigmaSigma(0.2);
331   
332   while ( ( p = (AliMpIntPair*)next() ) )
333   {
334     ++nmanus;
335     AliMUONVCalibParam* ped = new AliMUONCalibParamNF(2,nChannels,AliMUONVCalibParam::InvalidFloatValue());
336     
337     Int_t detElemId = p->GetFirst();
338         
339     Int_t manuId = p->GetSecond();
340     
341     const AliMpVSegmentation* seg = 
342       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
343     
344     for ( Int_t manuChannel = 0; manuChannel < nChannels; ++manuChannel )
345     {
346       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
347       if (!pad.IsValid()) continue;
348       
349       ++nchannels;
350       
351       Float_t meanPedestal;
352       Float_t sigmaPedestal;
353       
354       if ( defaultValues ) 
355       {
356         meanPedestal = 0.0;
357         sigmaPedestal = 1.0;
358       }
359       else
360       {
361         meanPedestal = -1;
362         while ( meanPedestal < 0 )
363         {
364           meanPedestal = gRandom->Gaus(kPedestalMeanMean,kPedestalMeanSigma);
365         }
366         sigmaPedestal = -1;
367         while ( sigmaPedestal < 0 )
368         {
369           sigmaPedestal = gRandom->Gaus(kPedestalSigmaMean,kPedestalSigmaSigma);
370         }
371       }
372       ped->SetValueAsFloat(manuChannel,0,meanPedestal);
373       ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
374       
375     }
376     Bool_t ok = pedestalStore.Set(detElemId,manuId,ped,replace);
377     if (!ok)
378     {
379       cout << "Could not set DetElemId=" << detElemId << " manuId="
380       << manuId << endl;
381     }
382   }
383   
384   delete list;
385   cout << nmanus << " Manus and " << nchannels << " channels." << endl;
386   return nchannels;
387   
388 }
389
390 //_____________________________________________________________________________
391 Int_t makeGainStore(AliMUONV2DStore& gainStore, Bool_t defaultValues)
392 {  
393   TList* list = AliMpManuList::ManuList();
394   TIter next(list);
395   
396   AliMpIntPair* p;
397   
398   Int_t nchannels(0);
399   Int_t nmanus(0);
400   
401   Bool_t replace = kFALSE;
402   
403   const Int_t nChannels(64);
404   const Double_t kSaturation(3000);
405   const Double_t kGainMean(1.0);
406   const Double_t kGainSigma(0.05);
407   
408   while ( ( p = (AliMpIntPair*)next() ) )
409   {
410     ++nmanus;
411     AliMUONVCalibParam* gain = new AliMUONCalibParamNF(2,nChannels,AliMUONVCalibParam::InvalidFloatValue());
412
413     Int_t detElemId = p->GetFirst();
414     Int_t manuId = p->GetSecond();
415
416     const AliMpVSegmentation* seg = 
417       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
418
419     for ( Int_t manuChannel = 0; manuChannel < nChannels; ++manuChannel )
420     {
421       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
422       if (!pad.IsValid()) continue;
423       
424       ++nchannels;
425       
426       Float_t meanGain;
427       Float_t saturation(kSaturation);
428     
429       if ( defaultValues ) 
430       {
431         meanGain = 1.0;
432       }
433       else
434       {
435         meanGain = -1;
436         while ( meanGain < 0 )
437         {
438           meanGain = gRandom->Gaus(kGainMean,kGainSigma);
439         }
440       }
441       gain->SetValueAsFloat(manuChannel,0,meanGain);
442       gain->SetValueAsFloat(manuChannel,1,saturation);
443       
444     }
445     Bool_t ok = gainStore.Set(detElemId,manuId,gain,replace);
446     if (!ok)
447     {
448       cout << "Could not set DetElemId=" << detElemId << " manuId="
449         << manuId << endl;
450     }
451   }
452   
453   delete list;
454   cout << nmanus << " Manus and " << nchannels << " channels." << endl;
455   return nchannels;
456 }
457
458 //_____________________________________________________________________________
459 void testMakeStores(Int_t readLoop)
460 {
461   AliMUONV2DStore* pedestalStore = new AliMUON2DMap;
462   AliMUONV2DStore* gainStore = new AliMUON2DMap;
463   
464   TStopwatch timer;
465   
466   cout << "Creating" << endl;
467   
468   Bool_t defaultValues = kTRUE;
469   
470   timer.Start(kTRUE);
471   makePedestalStore(*pedestalStore,defaultValues);
472   makeGainStore(*gainStore,defaultValues);
473   timer.Print();
474   
475   cout << "Reading..." << endl;
476   timer.Start(kTRUE);
477   testReadStore(*pedestalStore,readLoop);
478   testReadStore(*gainStore,readLoop);
479   cout << timer.CpuTime()/readLoop << " CPUs (mean of " << readLoop 
480     <<" samples." << endl;
481   
482   delete pedestalStore;
483   delete gainStore;
484 }
485
486 //_____________________________________________________________________________
487 void generateTrigger(const char* cdbpath)
488 {
489   // 
490   // Generate trigger related conditions :
491   //
492   // - trigger masks for board (locals, regionals, global)
493   // - trigger lut
494   // - trigger efficiency
495   // - trigger switches (to be implemented FIXME)
496   //
497   const Int_t nlboards = 234;
498   AliMUONV1DStore* localBoardMasks = new AliMUON1DArray(nlboards+1);
499   
500   // Generate fake mask values for 234 localboards and put that into
501   // one single container (localBoardMasks)
502   for ( Int_t i = 1; i <= nlboards; ++i )
503   {
504     AliMUONVCalibParam* localBoard = new AliMUONCalibParam1I(8);
505     for ( Int_t x = 0; x < 2; ++x )
506     {
507       for ( Int_t y = 0; y < 4; ++y )
508       {
509         Int_t index = x*4+y;
510         localBoard->SetValueAsInt(index,0,0xFFFF);
511       }
512     }
513     localBoardMasks->Set(i,localBoard,kFALSE);
514   }
515   
516   // Generate values for regional boards
517   const Int_t nrboards = 16;
518   AliMUONV1DStore* regionalBoardMasks = new AliMUON1DArray(16);
519   
520   for ( Int_t i = 0; i < nrboards; ++i )
521   {
522     AliMUONVCalibParam* regionalBoard = new AliMUONCalibParam1I(16);
523     for ( Int_t j = 0; j < 16; ++j )
524     {
525       regionalBoard->SetValueAsInt(j,0,0x3F);
526     }
527     regionalBoardMasks->Set(i,regionalBoard,kFALSE);
528   }
529   
530   // Generate values for global board
531   AliMUONVCalibParam* globalBoardMasks = new AliMUONCalibParam1I(16);
532   
533   for ( Int_t j = 0; j < 16; ++j )
534   {
535     globalBoardMasks->SetValueAsInt(j,0,0xFFF);
536   }
537     
538   AliMUONTriggerLut lut;
539   lut.ReadFromFile("$(ALICE_ROOT)/MUON/data/lutAptLpt1Hpt1p7.root");
540   
541   AliMUONTriggerEfficiencyCells cells("$ALICE_ROOT/MUON/data/efficiencyCells.dat");
542   
543   //--------------------------------------------
544   // Store the resulting containers into the CDB
545   Int_t ever = 99999999;
546   
547   AliCDBId id("MUON/Calib/LocalTriggerBoardMasks",0,ever);
548   
549   AliCDBMetaData md;
550   md.SetBeamPeriod(1);
551   md.SetAliRootVersion(gROOT->GetVersion());
552   md.SetComment("Test with default values");
553   md.SetResponsible("Rachid Guernane");
554   
555   AliCDBManager* man = AliCDBManager::Instance();
556   man->SetDefaultStorage(cdbpath);
557   man->Put(localBoardMasks,id,&md);
558   
559   id.SetPath("MUON/Calib/RegionalTriggerBoardMasks");
560   
561   man->Put(regionalBoardMasks,id,(AliCDBMetaData*)md.Clone());
562   
563   id.SetPath("MUON/Calib/GlobalTriggerBoardMasks");
564   
565   man->Put(globalBoardMasks,id,(AliCDBMetaData*)md.Clone());
566
567   id.SetPath("MUON/Calib/TriggerLut");
568   
569   man->Put(&lut,id,(AliCDBMetaData*)md.Clone());
570   
571   id.SetPath("MUON/Calib/TriggerEfficiency");
572   md.SetResponsible("Diego Stocco");
573   
574   man->Put(&cells,id,(AliCDBMetaData*)md.Clone());
575   
576   delete localBoardMasks;
577   delete regionalBoardMasks;
578   delete globalBoardMasks;
579 }
580
581
582 //_____________________________________________________________________________
583 void writeToCDB(const char* cdbpath, const char* calibpath, TObject* object, 
584                 Int_t startRun, Int_t endRun, Bool_t defaultValues)
585 {
586   AliCDBId id(calibpath,startRun,endRun);
587   AliCDBMetaData md;
588   md.SetBeamPeriod(1);
589   md.SetAliRootVersion(gROOT->GetVersion());
590   if ( defaultValues )
591   {
592     md.SetComment("Test with default values");
593   }
594   else
595   {
596     md.SetComment("Test with random values");
597   }
598   md.SetResponsible("Laurent Aphecetche");
599   
600   AliCDBManager* man = AliCDBManager::Instance();
601   man->SetDefaultStorage(cdbpath);
602   man->Put(object,id,&md);
603 }
604
605 //_____________________________________________________________________________
606 Int_t makeNeighbourStore(AliMUONV2DStore& neighbourStore)
607 {
608   /// Fill the neighbours store with, for each channel, a TObjArray of its
609   /// neighbouring pads (including itself)
610   
611   TStopwatch timer;
612   
613   timer.Start(kTRUE);
614   
615   TList* list = AliMpManuList::ManuList();
616   TIter next(list);
617   
618   AliMpIntPair* p;
619   
620   Int_t nchannels(0);
621   
622   TObjArray tmp;
623   
624   while ( ( p = (AliMpIntPair*)next() ) )
625   {
626     TObjArray* neighbours = new TObjArray(64);
627     neighbours->SetOwner(kTRUE);
628
629     Int_t detElemId = p->GetFirst();
630     Int_t manuId = p->GetSecond();
631     
632     const AliMpVSegmentation* seg = 
633       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
634     
635     for ( Int_t manuChannel = 0; manuChannel < 64; ++manuChannel )
636     {
637       AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
638       AliMUONVCalibParam* calibParam(0x0);
639       
640       if (pad.IsValid()) 
641       {
642         ++nchannels;
643
644         seg->GetNeighbours(pad,tmp,true,true);
645         Int_t nofPadNeighbours = tmp.GetEntriesFast();
646             
647         calibParam = new AliMUONCalibParam1I(nofPadNeighbours);
648         for ( Int_t i = 0; i < nofPadNeighbours; ++i )
649         {
650           AliMpPad* pad = static_cast<AliMpPad*>(tmp.At(i));
651           Int_t x = pad->GetLocation().GetFirst() * 1000000 + pad->GetLocation().GetSecond();
652           calibParam->SetValueAsInt(i,0,x);
653         }
654       }
655       neighbours->AddAt(calibParam,manuChannel);
656     }
657
658     Bool_t ok = neighbourStore.Set(detElemId,manuId,neighbours,kFALSE);
659     if (!ok)
660     {
661       cout << "Could not set DetElemId=" << detElemId << " manuId="
662       << manuId << endl;
663       return -1;
664     }
665   }
666   
667   timer.Print();
668   
669   return nchannels;
670 }
671
672 //_____________________________________________________________________________
673 void writeNeighbours(const char* cdbpath, Int_t startRun, Int_t endRun)
674 {
675   AliMUONV2DStore* neighbours = new AliMUON2DMap(kTRUE);
676   Int_t ngenerated = makeNeighbourStore(*neighbours);
677   cout << "Ngenerated = " << ngenerated << endl;
678   if (ngenerated>0)
679   {
680     writeToCDB(cdbpath,"MUON/Calib/Neighbours",neighbours,startRun,endRun,true);
681   }
682   delete neighbours;
683 }
684
685 //_____________________________________________________________________________
686 void writeHV(const char* cdbpath, Bool_t defaultValues,
687              Int_t startRun, Int_t endRun)
688 {
689   /// generate HV values (either cste = 1500 V) if defaultValues=true or random
690   /// if defaultValues=false, see makeHVStore) and
691   /// store them into CDB located at cdbpath, with a validity period
692   /// ranging from startRun to endRun
693   
694   TMap* hvStore = new TMap;
695   Int_t ngenerated = makeHVStore(*hvStore,defaultValues);
696   cout << "Ngenerated = " << ngenerated << endl;
697   if (ngenerated>0)
698   {
699     writeToCDB(cdbpath,"MUON/Calib/HV",hvStore,startRun,endRun,defaultValues);
700   }
701   delete hvStore;
702 }
703
704 //_____________________________________________________________________________
705 void writePedestals(const char* cdbpath, Bool_t defaultValues,
706                     Int_t startRun, Int_t endRun)
707 {
708   /// generate pedestal values (either 0 if defaultValues=true or random
709   /// if defaultValues=false, see makePedestalStore) and
710   /// store them into CDB located at cdbpath, with a validity period
711   /// ranging from startRun to endRun
712   
713   AliMUONV2DStore* pedestalStore = new AliMUON2DMap;
714   Int_t ngenerated = makePedestalStore(*pedestalStore,defaultValues);
715   cout << "Ngenerated = " << ngenerated << endl;
716   
717   writeToCDB(cdbpath,"MUON/Calib/Pedestals",pedestalStore,startRun,endRun,defaultValues);
718   delete pedestalStore;
719 }
720
721 //_____________________________________________________________________________
722 void writeGains(const char* cdbpath, Bool_t defaultValues,
723                     Int_t startRun, Int_t endRun)
724 {
725   /// generate gain values (either 1 if defaultValues=true or random
726   /// if defaultValues=false, see makePedestalStore) and
727   /// store them into CDB located at cdbpath, with a validity period
728   /// ranging from startRun to endRun
729   
730   AliMUONV2DStore* gainStore = new AliMUON2DMap;
731   Int_t ngenerated = makeGainStore(*gainStore,defaultValues);
732   cout << "Ngenerated = " << ngenerated << endl;
733   
734   writeToCDB(cdbpath,"MUON/Calib/Gains",gainStore,startRun,endRun,defaultValues);
735   delete gainStore;
736 }
737
738 //_____________________________________________________________________________
739 Bool_t check1I(const AliMUONVCalibParam& calib, Int_t channel)
740 {
741   /// 
742   
743   return ( calib.ValueAsInt(channel) == 0);
744 }
745
746 //_____________________________________________________________________________
747 void validate1I(const AliMUONV2DStore& store)
748 {
749   AliMUON2DStoreValidator validator;
750   
751   TObjArray* a = validator.Validate(store,check1I);
752   
753   if (a) a->Print();
754   
755   TList lines;
756   
757   validator.Report(lines);
758   
759   lines.Print();
760 }
761
762 //_____________________________________________________________________________
763 void validate2F(const AliMUONV2DStore& store)
764 {
765   AliMUON2DStoreValidator validator;
766   
767   TObjArray* a = validator.Validate(store,AliMUONVCalibParam::InvalidFloatValue());
768   
769   if (a) a->Print();
770   
771   TList lines;
772   
773   validator.Report(lines);
774   
775   lines.Print();
776 }
777
778 //_____________________________________________________________________________
779 void dump(const TArrayI& a, const char* what)
780 {
781   cout << what << " " << a.GetSize() << " manus" << endl;
782   for ( Int_t i = 0; i < a.GetSize(); ++i ) 
783   {
784     cout << Form(" %5d ",a[i]);
785   }
786   cout << endl;
787 }
788
789 //_____________________________________________________________________________
790 void countManus()
791 {
792   AliMpDEIterator it;
793   
794   it.First();
795   
796   Int_t b(0);
797   Int_t nb(0);
798   
799   while (!it.IsDone())
800   {
801     Int_t detElemId = it.CurrentDEId();
802     AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
803     if ( stationType != AliMp::kStationTrigger ) 
804     {
805       const AliMpVSegmentation* seg0 = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
806       const AliMpVSegmentation* seg1 = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath1);
807       TArrayI a1;
808       TArrayI a0;
809       seg0->GetAllElectronicCardIDs(a0);
810       seg1->GetAllElectronicCardIDs(a1);
811       
812       cout << Form("DE %5d B %4d NB %4d Total %5d",detElemId,
813                    a0.GetSize(),a1.GetSize(),a0.GetSize()+a1.GetSize())            
814         << endl;
815       
816       b += a0.GetSize();
817       nb += a1.GetSize();
818       
819       if ( detElemId == 500 ) 
820       {
821         dump(a0,"B");
822         dump(a1,"NB");
823       }
824     }
825     it.Next();
826   }
827   
828   cout << Form("B %5d NB %5d Total %5d",b,nb,b+nb) << endl;
829 }
830
831 //_____________________________________________________________________________
832 void count(const AliMUONV2DStore& store)
833 {
834   AliMUONVDataIterator* it = store.Iterator();
835   AliMUONObjectPair* pair;
836   std::map<int,std::pair<int,int> > demap;
837   
838   while ( ( pair = static_cast<AliMUONObjectPair*>(it->Next()) ) )
839   {
840     AliMpIntPair* ip = static_cast<AliMpIntPair*>(pair->First());
841     
842     Int_t detElemId = ip->GetFirst();
843     
844     Int_t manuId = ip->GetSecond();
845     
846     const AliMpVSegmentation* seg = 
847       AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
848     
849     if ( seg->PlaneType() == AliMp::kNonBendingPlane ) 
850     {
851       demap[detElemId].second++;
852     }
853     else
854     {
855       demap[detElemId].first++;
856     }    
857   }
858   
859   std::map<int,std::pair<int,int> >::const_iterator mit;
860   
861   Int_t b(0);
862   Int_t nb(0);
863   
864   for ( mit = demap.begin(); mit != demap.end(); ++mit ) 
865   {
866     cout << Form("DE %5d B %4d NB %4d Total %5d",mit->first,
867                  mit->second.first,mit->second.second,
868                  mit->second.first+mit->second.second) << endl;
869     b += mit->second.first;
870     nb += mit->second.second;    
871   }
872   
873   cout << Form("B %5d NB %5d Total %5d",b,nb,b+nb) << endl;  
874 }
875
876