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