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