MUON/AliMUONTrackerData.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 #include "AliMUONTrackerData.h"
  19
  20 #include "AliCodeTimer.h"
  21 #include "AliDAQ.h"
  22 #include "AliLog.h"
  23 #include "AliMUON1DArray.h"
  24 #include "AliMUON1DMap.h"
  25 #include "AliMUON2DMap.h"
  26 #include "AliMUONCalibParamND.h"
  27 #include "AliMUONSparseHisto.h"
  28 #include "AliMUONVStore.h"
  29 #include "AliMpBusPatch.h"
  30 #include "AliMpConstants.h"
  31 #include "AliMpCDB.h"
  32 #include "AliMpDDLStore.h"
  33 #include "AliMpManuStore.h"
  34 #include "AliMpDEIterator.h"
  35 #include "AliMpDEManager.h"
  36 #include "AliMpDetElement.h"
  37 #include "AliMpDCSNamer.h"
  38 #include "AliMpManuIterator.h"
  39 #include "AliMpEncodePair.h"
  40 #include "AliMpSegmentation.h"
  41 #include <Riostream.h>
  42 #include <TClass.h>
  43 #include <TMath.h>
  44 #include <TObjArray.h>
  45 #include <TObjString.h>
  46 #include <TString.h>
  47 #include <TTimeStamp.h>
  48 #include <TVector2.h>
  49 #include <cassert>
  50 #include <float.h>
  51
  52 /// \class AliMUONTrackerData
  53 ///
  54 /// Implementation of AliMUONVTrackerData class
  55 ///
  56 /// \author Laurent Aphecetche, Subatech
  57
  58 ///\cond CLASSIMP
  59 ClassImp(AliMUONTrackerData)
  60 ///\endcond
  61
  62 const Int_t AliMUONTrackerData::fgkExtraDimension = 2;
  63 const Int_t AliMUONTrackerData::fgkVirtualExtraDimension = 1;
  64
  65 //_____________________________________________________________________________
  66 AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title,
  67                                        Int_t dimension,
  68                                        Bool_t issingleevent)
  69 : AliMUONVTrackerData(name,title),
  70 fIsSingleEvent(issingleevent),
  71 fChannelValues(0x0),
  72 fManuValues(0x0),
  73 fBusPatchValues(0x0),
  74 fDEValues(0x0),
  75 fChamberValues(0x0),
  76 fPCBValues(0x0),
  77 fDimension(External2Internal(dimension)+fgkExtraDimension),
  78 fNevents(0),
  79 fDimensionNames(new TObjArray(fDimension+fgkVirtualExtraDimension)),
  80 fExternalDimensionNames(new TObjArray(dimension)),
  81 fExternalDimension(dimension),
  82 fHistogramming(new Int_t[fExternalDimension]),
  83 fHistos(0x0),
  84 fXmin(0.0),
  85 fXmax(0.0),
  86 fIsChannelLevelEnabled(kTRUE),
  87 fIsManuLevelEnabled(kTRUE),
  88 fNofDDLs(0),
  89 fNofEventsPerDDL(0x0)
  90 {
  91   /// ctor
  92   memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
  93   fExternalDimensionNames->SetOwner(kTRUE);
  94   fDimensionNames->SetOwner(kTRUE);
  95   fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
  96   fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
  97   fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
  98   Clear();
  99 }
 100
 101 //_____________________________________________________________________________
 102 AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title,
 103                                        const AliMUONVStore& manuValues)
 104 : AliMUONVTrackerData(name,title),
 105 fIsSingleEvent(kFALSE),
 106 fChannelValues(0x0),
 107 fManuValues(0x0),
 108 fBusPatchValues(0x0),
 109 fDEValues(0x0),
 110 fChamberValues(0x0),
 111 fPCBValues(0x0),
 112 fDimension(0),
 113 fNevents(0),
 114 fDimensionNames(0x0),
 115 fExternalDimensionNames(0x0),
 116 fExternalDimension(0),
 117 fHistogramming(0x0),
 118 fHistos(0x0),
 119 fXmin(0.0),
 120 fXmax(0.0),
 121 fIsChannelLevelEnabled(kFALSE),
 122 fIsManuLevelEnabled(kTRUE),
 123 fNofDDLs(0),
 124 fNofEventsPerDDL(0x0)
 125 {
 126   /// ctor with pre-computed values at the manu level
 127   /// In this case, we force fIsChannelLevelEnabled = kFALSE
 128   /// ctor
 129
 130   if (manuValues.GetSize()==0)
 131   {
 132     AliFatal("Cannot create a tracker data from nothing in that case !");
 133   }
 134
 135   if ( !AliMpDDLStore::Instance(kFALSE) && !AliMpManuStore::Instance(kFALSE) )
 136   {
 137     AliError("Cannot work without (full) mapping");
 138     return;
 139   }
 140
 141   TIter next(manuValues.CreateIterator());
 142   AliMUONVCalibParam* m = static_cast<AliMUONVCalibParam*>(next());
 143
 144   Int_t dimension = ( m->Dimension() - fgkExtraDimension - fgkVirtualExtraDimension ) / 2;
 145
 146   fDimension = External2Internal(dimension)+fgkExtraDimension;
 147
 148   fDimensionNames = new TObjArray(fDimension+fgkVirtualExtraDimension);
 149   fExternalDimensionNames = new TObjArray(dimension);
 150   fExternalDimension = dimension;
 151   fHistogramming = new Int_t[fExternalDimension];
 152   memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
 153
 154   fExternalDimensionNames->SetOwner(kTRUE);
 155   fDimensionNames->SetOwner(kTRUE);
 156   fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
 157   fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
 158   fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
 159   Clear();
 160   TArrayI nevents(AliDAQ::NumberOfDdls("MUONTRK"));
 161   AssertStores();
 162
 163   next.Reset();
 164   AliMUONVCalibParam* external;
 165
 166   while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
 167   {
 168     Int_t detElemId, manuId;
 169
 170     GetDEManu(*external,detElemId,manuId);
 171
 172     AliMUONVCalibParam* chamber(0x0);
 173     AliMUONVCalibParam* de(0x0);
 174     AliMUONVCalibParam* busPatch(0x0);
 175     AliMUONVCalibParam* pcb(0x0);
 176     AliMUONVCalibParam* manu(0x0);
 177     AliMUONVCalibParam* channel(0x0);
 178     AliMpDetElement* mpde(0x0);
 179
 180     AliMUONVCalibParam* wec = new AliMUONCalibParamND(external->Dimension()-1,1,detElemId,manuId,0);
 181     // as external, but without event count
 182     wec->SetValueAsDouble(0,0,external->ValueAsDouble(0,0));
 183     wec->SetValueAsDouble(0,1,external->ValueAsDouble(0,1));
 184     wec->SetValueAsDouble(0,2,external->ValueAsDouble(0,2));
 185     wec->SetValueAsDouble(0,3,external->ValueAsDouble(0,3));
 186
 187     Int_t mid = GetParts(wec,chamber,de,busPatch,pcb,manu,channel,mpde);
 188
 189     if ( manuId != mid )
 190     {
 191       AliError(Form("Something is wrong for DE %5d : manuId = %d vs mid = %d",detElemId,manuId,mid));
 192       continue;
 193     }
 194
 195     if ( manuId < 0 )
 196     {
 197       AliError("Got a < 0 manuId. Should not happen here !");
 198       continue;
 199     }
 200
 201     assert(channel==0x0);
 202
 203     Int_t n1 = manu->ValueAsInt(0,IndexOfNumberDimension());
 204     Int_t n2 = external->ValueAsInt(0,IndexOfNumberDimension());
 205     if  ( n1 != n2 )
 206     {
 207       AliError(Form("Incoherent number of manu channels for DE %5d MANU %5d : %d vs %d",
 208                     detElemId,manuId,n1,n2));
 209     }
 210
 211     Int_t nevt = external->ValueAsInt(0,4);
 212
 213     Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
 214
 215     Int_t ddl = AliMpDDLStore::Instance()->GetDDLfromBus(busPatchId);
 216
 217     if ( nevents[ddl] == 0 )
 218     {
 219       nevents[ddl] = nevt;
 220     }
 221     else
 222     {
 223       if ( nevents.At(ddl) != nevt )
 224       {
 225         AliError(Form("Nevt mismatch for DE %5d MANU %5d DDL %d : %d vs %d",
 226                       detElemId,manuId,ddl,nevents.At(ddl),nevt));
 227         continue;
 228       }
 229     }
 230
 231     for ( Int_t i = 0; i < wec->Dimension()-1; ++i )
 232     {
 233       manu->SetValueAsDouble(0,i,manu->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
 234
 235       busPatch->SetValueAsDouble(0,i,busPatch->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
 236
 237       de->SetValueAsDouble(0,i,de->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
 238
 239       chamber->SetValueAsDouble(0,i,chamber->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
 240     }
 241     delete wec;
 242   }
 243
 244   UpdateNumberOfEvents(&nevents);
 245
 246 }
 247
 248
 249 //_____________________________________________________________________________
 250 AliMUONTrackerData::~AliMUONTrackerData()
 251 {
 252   /// dtor
 253   delete fChannelValues;
 254   delete fManuValues;
 255   delete fBusPatchValues;
 256   delete fDEValues;
 257   delete fChamberValues;
 258   delete fPCBValues;
 259   delete fDimensionNames;
 260   delete fExternalDimensionNames;
 261   delete[] fHistogramming;
 262   delete fHistos;
 263   delete[] fNofEventsPerDDL;
 264 }
 265
 266 //_____________________________________________________________________________
 267 Bool_t
 268 AliMUONTrackerData::Add(const AliMUONVStore& store, TArrayI* nevents)
 269 {
 270   /// Add the given external store to our internal store
 271   return InternalAdd(store,nevents,kFALSE);
 272 }
 273
 274 //_____________________________________________________________________________
 275 Bool_t
 276 AliMUONTrackerData::Add(const AliMUONTrackerData& data)
 277 {
 278   /// Add data to *this
 279   // We do this by looping on all VCalibParam stored in the various containers,
 280   // and simply adding the values there.
 281   // Same thing for the number of events per DDL.
 282   // Same thing for sparsehistograms, if we have some.
 283
 284   // First cross check we have compatible objects.
 285
 286   if ( fIsChannelLevelEnabled != data.fIsChannelLevelEnabled )
 287   {
 288     AliError("Incompatible IsChannelLevelEnabled status");
 289     return kFALSE;
 290   }
 291
 292   if ( fIsManuLevelEnabled != data.fIsManuLevelEnabled )
 293   {
 294     AliError("Incompatible IsManuLevelEnabled status");
 295     return kFALSE;
 296   }
 297
 298   if ( fIsSingleEvent != data.fIsSingleEvent )
 299   {
 300     AliError("Incompatible IsSingleEvent status");
 301     return kFALSE;
 302   }
 303
 304   if ( fDimension != data.fDimension || fExternalDimension != data.fExternalDimension )
 305   {
 306     AliError("Incompatible dimensions");
 307     return kFALSE;
 308   }
 309
 310   if ( fNofDDLs != data.fNofDDLs )
 311   {
 312     AliError("Incompatible number of Ddls");
 313     return kFALSE;
 314   }
 315
 316   if ( ( !fHistogramming && data.fHistogramming ) || ( fHistogramming && !data.fHistogramming )
 317       || fXmin != data.fXmin || fXmax != data.fXmax )
 318   {
 319     AliError(Form("Incompatible histogramming (%x vs %x) (xmax = %e vs %e ; xmin = %e vs %e)",
 320              fHistogramming,data.fHistogramming,fXmax,data.fXmax,fXmin,data.fXmin));
 321     return kFALSE;
 322   }
 323
 324   if ( fHistogramming )
 325   {
 326     for ( Int_t i = 0; i < fExternalDimension; ++i )
 327     {
 328       if ( fHistogramming[i] != data.fHistogramming[i] )
 329       {
 330         AliError(Form("Incompatible histogramming for external dimension %d",i));
 331         return kFALSE;
 332       }
 333     }
 334   }
 335
 336   // OK. Seems we have compatible objects, so we can proceed with the actual
 337   // merging...
 338
 339   if ( data.fChannelValues )
 340   {
 341     Add2D(*(data.fChannelValues),*fChannelValues);
 342   }
 343
 344   if ( data.fManuValues )
 345   {
 346     Add2D(*(data.fManuValues),*fManuValues);
 347   }
 348
 349   if ( data.fPCBValues )
 350   {
 351     Add2D(*(data.fPCBValues),*fPCBValues);
 352   }
 353
 354   if ( data.fBusPatchValues )
 355   {
 356     Add1D(*(data.fBusPatchValues),*fBusPatchValues);
 357   }
 358
 359   if ( data.fDEValues )
 360   {
 361     Add1D(*(data.fDEValues),*fDEValues);
 362   }
 363
 364   if ( data.fChamberValues )
 365   {
 366     Add1D(*(data.fChamberValues),*fChamberValues);
 367   }
 368
 369   for ( Int_t i = 0; i < fNofDDLs; ++i )
 370   {
 371     fNofEventsPerDDL[i] += data.fNofEventsPerDDL[i];
 372   }
 373
 374   if ( data.fHistos )
 375   {
 376     TIter nexthisto(data.fHistos->CreateIterator());
 377     AliMUONVStore* store;
 378     while ( ( store = static_cast<AliMUONVStore*>(nexthisto()) ) )
 379     {
 380       TIter ns(store->CreateIterator());
 381       AliMUONSparseHisto* h;
 382       while ( ( h = static_cast<AliMUONSparseHisto*>(ns()) ) )
 383       {
 384         AliMUONVStore* thisStore = static_cast<AliMUONVStore*>(fHistos->FindObject(store->GetUniqueID()));
 385
 386         if (!thisStore)
 387         {
 388           thisStore = store->Create();
 389           thisStore->SetUniqueID(store->GetUniqueID());
 390           fHistos->Add(thisStore);
 391         }
 392
 393         AliMUONSparseHisto* mine = static_cast<AliMUONSparseHisto*>(thisStore->FindObject(h->GetUniqueID()));
 394
 395         if (!mine)
 396         {
 397           thisStore->Add(h);
 398         }
 399         else
 400         {
 401           mine->Add(*h);
 402         }
 403       }
 404     }
 405   }
 406
 407   fNevents =  TMath::Max(fNevents,data.fNevents);
 408
 409   return kTRUE;
 410 }
 411
 412 //_____________________________________________________________________________
 413 void
 414 AliMUONTrackerData::Add2D(const AliMUONVStore& src, AliMUONVStore& dest) const
 415 {
 416   /// Add one 2d store to another
 417
 418   TIter next(src.CreateIterator());
 419   AliMUONVCalibParam* p;
 420
 421   while ( ( p = static_cast<AliMUONVCalibParam*>(next()) ) )
 422   {
 423     AliMUONVCalibParam* a = static_cast<AliMUONVCalibParam*>(dest.FindObject(p->ID0(),p->ID1()));
 424
 425     if (!a)
 426     {
 427       dest.Add(static_cast<AliMUONVCalibParam*>(p->Clone()));
 428     }
 429     else
 430     {
 431       AddCalibParams(*p,*a);
 432     }
 433   }
 434 }
 435
 436 //_____________________________________________________________________________
 437 void
 438 AliMUONTrackerData::Add1D(const AliMUONVStore& src, AliMUONVStore& dest) const
 439 {
 440   /// Add one 1d store to another
 441
 442   TIter next(src.CreateIterator());
 443   AliMUONVCalibParam* p;
 444
 445   while ( ( p = static_cast<AliMUONVCalibParam*>(next()) ) )
 446   {
 447     AliMUONVCalibParam* a = static_cast<AliMUONVCalibParam*>(dest.FindObject(p->GetUniqueID()));
 448
 449     if (!a)
 450     {
 451       dest.Add(static_cast<AliMUONVCalibParam*>(p->Clone()));
 452     }
 453     else
 454     {
 455       AddCalibParams(*p,*a);
 456     }
 457   }
 458 }
 459
 460 //_____________________________________________________________________________
 461 void
 462 AliMUONTrackerData::AddCalibParams(const AliMUONVCalibParam& src, AliMUONVCalibParam& dest) const
 463 {
 464   /// Add src to dest
 465   for ( Int_t i = 0; i < src.Size(); ++i )
 466   {
 467     for ( Int_t j = 0; j < src.Dimension(); ++j )
 468     {
 469       dest.SetValueAsFloat(i,j,src.ValueAsFloat(i,j));
 470     }
 471   }
 472 }
 473
 474 //_____________________________________________________________________________
 475 Bool_t
 476 AliMUONTrackerData::Replace(const AliMUONVStore& store)
 477 {
 478   /// Replace our values by values from the given external store
 479   Bool_t rv = InternalAdd(store,0x0,kTRUE);
 480   AliMUONVTrackerData::Replace(store);
 481   return rv;
 482 }
 483
 484 //_____________________________________________________________________________
 485 Bool_t
 486 AliMUONTrackerData::UpdateNumberOfEvents(TArrayI* nevents)
 487 {
 488   /// Update the number of events
 489
 490   if (!fNofDDLs)
 491   {
 492     fNofDDLs = AliDAQ::NumberOfDdls("MUONTRK");
 493     fNofEventsPerDDL = new Int_t[fNofDDLs];
 494     for ( Int_t i = 0; i < fNofDDLs; ++i )
 495     {
 496       fNofEventsPerDDL[i] = 0;
 497     }
 498   }
 499
 500   if (nevents)
 501   {
 502     if (nevents->GetSize() != fNofDDLs )
 503     {
 504       AliError(Form("nof of ddl per event array size is incorrect : got %d, expecting %d",
 505                     nevents->GetSize(),fNofDDLs));
 506       return kFALSE;
 507     }
 508
 509     for ( Int_t i = 0 ; i < fNofDDLs; ++i )
 510     {
 511       fNofEventsPerDDL[i] += nevents->At(i);
 512       fNevents = TMath::Max(fNevents,fNofEventsPerDDL[i]);
 513     }
 514   }
 515   else
 516   {
 517     for ( Int_t i = 0 ; i < fNofDDLs; ++i )
 518     {
 519       ++fNofEventsPerDDL[i];
 520       fNevents = TMath::Max(fNevents,fNofEventsPerDDL[i]);
 521     }
 522   }
 523   return kTRUE;
 524 }
 525
 526 //_____________________________________________________________________________
 527 void
 528 AliMUONTrackerData::AssertStores()
 529 {
 530   /// Insure our stores are allocated
 531
 532   if (!fChamberValues)
 533   {
 534     Int_t numberOfBusPatches(0);
 535     Int_t numberOfDEs(0);
 536
 537     // get number of bus patches and number of detection element
 538     // to initialize fBusPatchValues and fDEValues below
 539
 540     TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
 541     while ( next() ) ++numberOfBusPatches;
 542     AliMpDEIterator deIt;
 543     deIt.First();
 544     while (!deIt.IsDone())
 545     {
 546       ++numberOfDEs;
 547       deIt.Next();
 548     }
 549
 550     if ( fIsChannelLevelEnabled )
 551     {
 552       fChannelValues = new AliMUON2DMap(kTRUE);
 553     }
 554     if  ( fIsManuLevelEnabled )
 555     {
 556       fManuValues = new AliMUON2DMap(kTRUE);
 557     }
 558     fPCBValues = new AliMUON2DMap(kFALSE);
 559     fBusPatchValues = new AliMUON1DMap(numberOfBusPatches);
 560     fDEValues = new AliMUON1DMap(numberOfDEs);
 561     fChamberValues = new AliMUON1DArray;
 562   }
 563 }
 564
 565 //_____________________________________________________________________________
 566 Bool_t
 567 AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, TArrayI* nevents, Bool_t replace)
 568 {
 569   /// Add the given external store to our internal store
 570
 571   AliCodeTimerAuto(GetName(),0);
 572
 573   if ( !replace)
 574   {
 575     if ( IsSingleEvent() && NumberOfEvents(-1) == 1 )
 576     {
 577       AliError(Form("%s is supposed to be single event only",GetName()));
 578       return kFALSE;
 579     }
 580   }
 581
 582   UpdateNumberOfEvents(nevents);
 583
 584   AssertStores();
 585
 586   TIter next(store.CreateIterator());
 587   AliMUONVCalibParam* external;
 588
 589   Int_t nk(2);
 590
 591   if ( IsSingleEvent() ) nk = 1;
 592
 593   while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
 594   {
 595     if ( external->Dimension() != ExternalDimension() )
 596     {
 597       AliError(Form("Incompatible dimensions %d vs %d",
 598                     external->Dimension(),ExternalDimension()));
 599       return kFALSE;
 600     }
 601
 602     AliMUONVCalibParam* chamber(0x0);
 603     AliMUONVCalibParam* de(0x0);
 604     AliMUONVCalibParam* busPatch(0x0);
 605     AliMUONVCalibParam* pcb(0x0);
 606     AliMUONVCalibParam* manu(0x0);
 607     AliMUONVCalibParam* channel(0x0);
 608     AliMpDetElement* mpde(0x0);
 609
 610     Int_t manuId = GetParts(external,chamber,de,busPatch,pcb,manu,channel,mpde);
 611
 612     if ( manuId < 0 ) continue;
 613
 614     Int_t detElemId = mpde->GetId();
 615
 616     Double_t value[] = { 0.0, 0.0 };
 617
 618     Int_t nch = mpde->NofChannelsInManu(manuId);
 619
 620     for ( Int_t i = 0; i < external->Size(); ++i )
 621     {
 622       Bool_t existingChannel =  ( nch == AliMpConstants::ManuNofChannels() ? kTRUE
 623                                                                            : mpde->IsConnectedChannel(manuId,i));
 624       // note we only use IsConnectedChannel method when really needed, as
 625       // it costs (some) CPU time...
 626
 627       if ( existingChannel )
 628       {
 629         Bool_t validChannel(kFALSE);
 630
 631         for ( Int_t j = 0; j < external->Dimension(); ++j )
 632         {
 633           Double_t vext = external->IsDoublePrecision() ?
 634             external->ValueAsDoubleFast(i,j) :
 635             external->ValueAsFloatFast(i,j);
 636
 637           if ( vext >= AliMUONVCalibParam::InvalidFloatValue() ) continue;
 638
 639           validChannel = kTRUE;
 640
 641           Int_t ix = External2Internal(j);
 642
 643           value[0] = vext;
 644           value[1] = vext*vext;
 645
 646           if ( IsHistogrammed(j) )
 647           {
 648             FillHisto(detElemId,manuId,i,j,vext);
 649           }
 650
 651           for ( Int_t k = 0; k < nk; ++k )
 652           {
 653             Double_t e = ( replace && channel ) ? channel->ValueAsDoubleFast(i,ix+k) : 0.0;
 654
 655                                                 if ( channel )
 656                                                 {
 657                                                         channel->SetValueAsDoubleFast(i,ix+k,channel->ValueAsDoubleFast(i,ix+k)-e+value[k]);
 658                                                 }
 659
 660             if (manu)
 661             {
 662               manu->SetValueAsDoubleFast(0,ix+k,manu->ValueAsDoubleFast(0,ix+k)-e+value[k]);
 663             }
 664
 665             busPatch->SetValueAsDoubleFast(0,ix+k,busPatch->ValueAsDoubleFast(0,ix+k)-e+value[k]);
 666
 667             de->SetValueAsDoubleFast(0,ix+k,de->ValueAsDoubleFast(0,ix+k)-e+value[k]);
 668
 669             chamber->SetValueAsDoubleFast(0,ix+k,chamber->ValueAsDoubleFast(0,ix+k)-e+value[k]);
 670
 671             if ( pcb )
 672             {
 673               pcb->SetValueAsDoubleFast(0,ix+k,pcb->ValueAsDoubleFast(0,ix+k)-e+value[k]);
 674             }
 675           }
 676         }
 677
 678         if ( validChannel && !replace )
 679         {
 680                                         if ( channel )
 681                                         {
 682                                                 channel->SetValueAsDoubleFast(i,IndexOfOccupancyDimension(),
 683                                                                                                                                                                         channel->ValueAsDoubleFast(i,IndexOfOccupancyDimension())+1.0);
 684                                         }
 685
 686           if (manu)
 687           {
 688             manu->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
 689                                        manu->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);
 690           }
 691
 692           busPatch->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
 693                                                          busPatch->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);
 694           de->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
 695                                              de->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);
 696           chamber->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
 697                                                        chamber->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);
 698           if ( pcb )
 699           {
 700             pcb->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
 701                                       pcb->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);
 702           }
 703         }
 704       }
 705     }
 706   }
 707
 708   NumberOfEventsChanged();
 709
 710   return kTRUE;
 711 }
 712
 713 //_____________________________________________________________________________
 714 Double_t
 715 AliMUONTrackerData::BusPatch(Int_t busPatchId, Int_t dim) const
 716 {
 717   /// Return the value of a given buspatch for a given dimension
 718   /// or 0 if not existing
 719   AliMUONVCalibParam* param = BusPatchParam(busPatchId);
 720   return param ? Value(*param,0,dim,DdlIdFromBusPatchId(busPatchId)) : 0.0;
 721 }
 722
 723 //_____________________________________________________________________________
 724 AliMUONVCalibParam*
 725 AliMUONTrackerData::BusPatchParam(Int_t busPatchId, Bool_t create) const
 726 {
 727   /// Return (if it exist), the VCalibParam for a given busPatch
 728
 729   AliMUONVCalibParam* busPatch = fBusPatchValues ? static_cast<AliMUONVCalibParam*>
 730     (fBusPatchValues->FindObject(busPatchId)) : 0x0;
 731
 732   if (!busPatch && create && fBusPatchValues)
 733   {
 734     busPatch = CreateBusPatchParam(busPatchId);
 735     fBusPatchValues->Add(busPatch);
 736   }
 737
 738   return busPatch;
 739 }
 740
 741 //_____________________________________________________________________________
 742 AliMUONVCalibParam*
 743 AliMUONTrackerData::CreateBusPatchParam(Int_t busPatchId) const
 744 {
 745   /// Create storage for one bus patch
 746
 747   AliCodeTimerAuto("",0);
 748
 749   AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
 750
 751   if (!bp)
 752   {
 753     AliError(Form("Got an invalid buspatchId = %d",busPatchId));
 754     return 0x0;
 755   }
 756
 757   AliMUONVCalibParam* busPatch = new AliMUONCalibParamND(Dimension(),1,busPatchId,0,0.0);
 758
 759   // set the number of channels in that buspatch
 760
 761   Int_t nchannels(0);
 762
 763   Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
 764
 765   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 766
 767   for ( Int_t i = 0; i < bp->GetNofManus(); ++i )
 768   {
 769     Int_t manuId = bp->GetManuId(i);
 770     nchannels += de->NofChannelsInManu(manuId);
 771   }
 772
 773   busPatch->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels);
 774
 775   return busPatch;
 776 }
 777
 778 //_____________________________________________________________________________
 779 Double_t
 780 AliMUONTrackerData::Chamber(Int_t chamberId, Int_t dim) const
 781 {
 782   /// Return the value fo a given chamber for a given dimension,
 783   /// or zero if not existing
 784
 785   // FIXME: is the Value() correct wrt to number of events in the case of
 786   // chamber ? Or should we do something custom at the chamber level
 787   // (as it spans several ddls) ?
 788
 789   AliMUONVCalibParam* param = ChamberParam(chamberId);
 790   return param ? Value(*param,0,dim,DdlIdFromChamberId(chamberId)) : 0.0;
 791 }
 792
 793 //_____________________________________________________________________________
 794 AliMUONVCalibParam*
 795 AliMUONTrackerData::ChamberParam(Int_t chamberId, Bool_t create) const
 796 {
 797   /// Return (if it exist) the VCalibParam for a given chamber
 798
 799   AliMUONVCalibParam* chamber =  fChamberValues ? static_cast<AliMUONVCalibParam*>
 800   (fChamberValues->FindObject(chamberId)) : 0x0;
 801
 802   if (!chamber && create && fChamberValues)
 803   {
 804     chamber = CreateChamberParam(chamberId);
 805     fChamberValues->Add(chamber);
 806   }
 807
 808   return chamber;
 809 }
 810
 811 //_____________________________________________________________________________
 812 AliMUONVCalibParam*
 813 AliMUONTrackerData::CreateChamberParam(Int_t chamberId) const
 814 {
 815   /// Create storage for one chamber
 816
 817   AliCodeTimerAuto("",0);
 818
 819   AliMUONVCalibParam* chamber = new AliMUONCalibParamND(Dimension(),1,chamberId,0,0.0);
 820
 821   // set the number of channels in that chamber
 822
 823   Int_t nchannels(0);
 824
 825   AliMpDEIterator it;
 826
 827   it.First(chamberId);
 828
 829   while ( !it.IsDone() )
 830   {
 831     AliMpDetElement* det = it.CurrentDE();
 832
 833     for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i )
 834     {
 835       Int_t busPatchId = det->GetBusPatchId(i);
 836       AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
 837       for ( Int_t j = 0; j < bp->GetNofManus(); ++j )
 838       {
 839         Int_t manuId = bp->GetManuId(j);
 840         nchannels += det->NofChannelsInManu(manuId);
 841       }
 842     }
 843
 844     it.Next();
 845   }
 846
 847   chamber->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels);
 848
 849   return chamber;
 850 }
 851
 852 //_____________________________________________________________________________
 853 Double_t
 854 AliMUONTrackerData::Channel(Int_t detElemId, Int_t manuId,
 855                             Int_t manuChannel, Int_t dim) const
 856 {
 857   /// Return the value for a given channel for a given dimension
 858
 859   AliMUONVCalibParam* param = ChannelParam(detElemId,manuId);
 860
 861   return param ? Value(*param,manuChannel,dim,DdlIdFromDetElemId(detElemId)) : 0.0;
 862 }
 863
 864 //_____________________________________________________________________________
 865 AliMUONVCalibParam*
 866 AliMUONTrackerData::ChannelParam(Int_t detElemId, Int_t manuId,
 867                                  AliMUONVCalibParam* external) const
 868 {
 869   /// Return (if it exist) the VCalibParam for a given manu
 870
 871   AliMUONVCalibParam* param = fChannelValues ? static_cast<AliMUONVCalibParam*>
 872     (fChannelValues->FindObject(detElemId,manuId)) : 0x0 ;
 873
 874   if (!param && external && fChannelValues)
 875   {
 876     param = CreateDouble(*external,detElemId,manuId);
 877     fChannelValues->Add(param);
 878   }
 879
 880   return param;
 881 }
 882
 883 //_____________________________________________________________________________
 884 void
 885 AliMUONTrackerData::Clear(Option_t*)
 886 {
 887   /// Clear all the values
 888   if ( fChannelValues ) fChannelValues->Clear();
 889   if ( fManuValues ) fManuValues->Clear();
 890   if ( fBusPatchValues) fBusPatchValues->Clear();
 891   if ( fPCBValues ) fPCBValues->Clear();
 892   if ( fDEValues) fDEValues->Clear();
 893   if ( fChamberValues ) fChamberValues->Clear();
 894   if ( fHistos ) fHistos->Clear();
 895   for ( Int_t i = 0; i < fNofDDLs; ++i )
 896   {
 897     fNofEventsPerDDL[i] = 0;
 898   }
 899   NumberOfEventsChanged();
 900 }
 901
 902 //_____________________________________________________________________________
 903 Double_t
 904 AliMUONTrackerData::Count(Int_t detElemId, Int_t manuId,
 905                           Int_t manuChannel) const
 906 {
 907   /// Return the number of times a given channel had data
 908
 909   return Channel(detElemId,manuId,manuChannel,IndexOfNumberDimension());
 910 }
 911
 912 //_____________________________________________________________________________
 913 AliMUONVCalibParam*
 914 AliMUONTrackerData::CreateDouble(const AliMUONVCalibParam& param,
 915                                  Int_t detElemId, Int_t manuId) const
 916 {
 917   /// Create a double version of VCalibParam, for internal use
 918
 919   AliCodeTimerAuto("",0);
 920
 921   AliMUONVCalibParam* c = new AliMUONCalibParamND(Dimension(),
 922                                                   param.Size(),
 923                                                   detElemId,
 924                                                   manuId,
 925                                                   0.0);
 926
 927   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId,manuId);
 928
 929   for ( Int_t i = 0; i < c->Size(); ++i )
 930   {
 931     Double_t value(0.0);
 932
 933     if ( de->IsConnectedChannel(manuId,i) ) value = 1.0;
 934
 935     c->SetValueAsDouble(i,IndexOfNumberDimension(),value);
 936   }
 937
 938   return c;
 939 }
 940
 941 //_____________________________________________________________________________
 942 Double_t
 943 AliMUONTrackerData::DetectionElement(Int_t detElemId, Int_t dim) const
 944 {
 945   /// Return the value for a given detection element for a given dimension
 946   AliMUONVCalibParam* param = DetectionElementParam(detElemId);
 947   return param ? Value(*param,0,dim,DdlIdFromDetElemId(detElemId)) : 0.0;
 948
 949 }
 950
 951 //_____________________________________________________________________________
 952 AliMUONVCalibParam*
 953 AliMUONTrackerData::DetectionElementParam(Int_t detElemId, Bool_t create) const
 954 {
 955   /// Return (if it exist) the VCalibParam for a given detection element
 956
 957   AliMUONVCalibParam* de = fDEValues ? static_cast<AliMUONVCalibParam*>
 958     (fDEValues->FindObject(detElemId)) : 0x0 ;
 959
 960   if (!de && create && fDEValues)
 961   {
 962     de = CreateDetectionElementParam(detElemId);
 963     fDEValues->Add(de);
 964   }
 965
 966   return de;
 967
 968 }
 969
 970 //_____________________________________________________________________________
 971 AliMUONVCalibParam*
 972 AliMUONTrackerData::CreateDetectionElementParam(Int_t detElemId) const
 973 {
 974   /// Create storage for one detection element
 975
 976   AliCodeTimerAuto("",0);
 977
 978   AliMUONVCalibParam*  de = new AliMUONCalibParamND(Dimension(),1,detElemId,0,0.0);
 979
 980   AliMpDetElement* det = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 981   Int_t nchannels(0);
 982
 983   for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i )
 984   {
 985     Int_t busPatchId = det->GetBusPatchId(i);
 986     AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
 987     for ( Int_t j = 0; j < bp->GetNofManus(); ++j )
 988     {
 989       Int_t manuId = bp->GetManuId(j);
 990       nchannels += det->NofChannelsInManu(manuId);
 991     }
 992   }
 993
 994   de->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels);
 995
 996   return de;
 997 }
 998
 999 //_____________________________________________________________________________
1000 Int_t
1001 AliMUONTrackerData::DdlIdFromBusPatchId(Int_t buspatchid) const
1002 {
1003   /// Get the "local" ddlid (0..19) of a given buspatch
1004   AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(buspatchid);
1005   if (bp)
1006   {
1007     return bp->GetDdlId();
1008   }
1009   return -1;
1010 }
1011
1012 //_____________________________________________________________________________
1013 Int_t
1014 AliMUONTrackerData::DdlIdFromDetElemId(Int_t detelemid) const
1015 {
1016   /// Get the "local" ddlid (0..19) of a given detection element
1017   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detelemid);
1018   if (de)
1019   {
1020     return de->GetDdlId();
1021   }
1022   return -1;
1023 }
1024
1025 //_____________________________________________________________________________
1026 Int_t
1027 AliMUONTrackerData::DdlIdFromChamberId(Int_t chamberid) const
1028 {
1029   /// Get the "local" ddlid (0..19) of a given chamber
1030   /// This has no real meaning (as there are several ddls per chamber),
1031   /// so we take the ddlid where we got the max number of events
1032
1033   AliMpDEIterator it;
1034
1035   it.First(chamberid);
1036   Int_t n(0);
1037   Int_t d(-1);
1038
1039   while (!it.IsDone())
1040   {
1041     Int_t detElemId = it.CurrentDEId();
1042     Int_t ddlId = DdlIdFromDetElemId(detElemId);
1043     if ( NumberOfEvents(ddlId) > n )
1044     {
1045       n = NumberOfEvents(ddlId);
1046       d = ddlId;
1047     }
1048     it.Next();
1049   }
1050
1051   return d;
1052 }
1053
1054 //_____________________________________________________________________________
1055 TString
1056 AliMUONTrackerData::DimensionName(Int_t dim) const
1057 {
1058   /// Get the name of a given dimension
1059   TObjString* value = static_cast<TObjString*>(fDimensionNames->At(dim));
1060   if ( value )
1061   {
1062     return value->String();
1063   }
1064   else
1065   {
1066     return TString("Invalid");
1067   }
1068 }
1069
1070 //_____________________________________________________________________________
1071 void
1072 AliMUONTrackerData::DisableChannelLevel()
1073 {
1074   /// Disable the storing of data at channel level
1075
1076   delete fChannelValues;
1077   fChannelValues = 0x0;
1078   fIsChannelLevelEnabled = kFALSE;
1079 }
1080
1081 //_____________________________________________________________________________
1082 void
1083 AliMUONTrackerData::DisableManuLevel()
1084 {
1085   /// Disable the storing of data at manu level (and below)
1086
1087   DisableChannelLevel();
1088   delete fManuValues;
1089   fManuValues = 0x0;
1090   fIsManuLevelEnabled = kFALSE;
1091 }
1092
1093 //_____________________________________________________________________________
1094 Int_t
1095 AliMUONTrackerData::External2Internal(Int_t index) const
1096 {
1097   /// From external to internal dimension
1098   return IsSingleEvent() ? index : index*2;
1099 }
1100
1101 //_____________________________________________________________________________
1102 TString
1103 AliMUONTrackerData::ExternalDimensionName(Int_t dim) const
1104 {
1105   /// Get the name of a given external dimension
1106
1107   TObjString* value = static_cast<TObjString*>(fExternalDimensionNames->At(dim));
1108   if ( value )
1109   {
1110     return value->String();
1111   }
1112   else
1113   {
1114     return TString("Invalid");
1115   }
1116 }
1117
1118 //_____________________________________________________________________________
1119 void
1120 AliMUONTrackerData::FillHisto(Int_t detElemId, Int_t manuId, Int_t manuChannel,
1121                               Int_t dim, Double_t value)
1122 {
1123   /// Fill histogram of a given channel
1124
1125   AliMUONSparseHisto* h(0x0);
1126
1127         if ( fIsChannelLevelEnabled )
1128         {
1129                 h = GetChannelSparseHisto(detElemId, manuId, manuChannel,dim);
1130   }
1131   else if ( fIsManuLevelEnabled )
1132   {
1133     h = GetManuSparseHisto(detElemId,manuId,dim);
1134   }
1135
1136   AliDebug(1,Form("DE %04d MANU %04d CH %02d dim %d value %e h %p",detElemId,manuId,manuChannel,dim,value,h));
1137
1138   if (h)
1139   {
1140                 h->Fill(static_cast<Int_t>(TMath::Nint(value)));
1141         }
1142 }
1143
1144 //_____________________________________________________________________________
1145 AliMUONSparseHisto*
1146 AliMUONTrackerData::GetManuSparseHisto(Int_t detElemId, Int_t manuId,
1147                                        Int_t dim) const
1148 {
1149   /// Get histogram of a given manu
1150
1151   if (!fHistos) return 0x0;
1152
1153   AliMUON1DArray* m = static_cast<AliMUON1DArray*>(fHistos->FindObject(detElemId,manuId));
1154   if (!m) return 0x0;
1155
1156   AliMUONSparseHisto* h = static_cast<AliMUONSparseHisto*>(m->FindObject(dim));
1157
1158   return h;
1159 }
1160
1161 //_____________________________________________________________________________
1162 AliMUONSparseHisto*
1163 AliMUONTrackerData::GetManuSparseHisto(Int_t detElemId, Int_t manuId, Int_t dim)
1164 {
1165   /// Get histogram of a given manu. Create it if necessary
1166
1167   if (!fHistos) fHistos = new AliMUON2DMap(kTRUE);
1168
1169   AliMUON1DArray* m = static_cast<AliMUON1DArray*>(fHistos->FindObject(detElemId,manuId));
1170   if (!m)
1171   {
1172     m = new AliMUON1DArray(NumberOfDimensions());
1173     m->SetUniqueID( ( manuId << 16 ) | detElemId );
1174     fHistos->Add(m);
1175   }
1176
1177   AliMUONSparseHisto* h = static_cast<AliMUONSparseHisto*>(m->FindObject(dim));
1178   if (!h)
1179   {
1180     h = new AliMUONSparseHisto(fXmin,fXmax);
1181
1182     h->SetUniqueID(dim);
1183
1184     m->Add(h);
1185   }
1186
1187    return h;
1188 }
1189
1190 //_____________________________________________________________________________
1191 AliMUONSparseHisto*
1192 AliMUONTrackerData::GetChannelSparseHisto(Int_t detElemId, Int_t manuId,
1193                                           Int_t manuChannel, Int_t dim) const
1194 {
1195   /// Get histogram of a given channel
1196
1197   if (!fHistos) return 0x0;
1198
1199   AliMUON1DMap* m = static_cast<AliMUON1DMap*>(fHistos->FindObject(detElemId,manuId));
1200   if (!m) return 0x0;
1201
1202   UInt_t uid = ( manuChannel << 16 ) | dim;
1203
1204   AliMUONSparseHisto* h = static_cast<AliMUONSparseHisto*>(m->FindObject(uid));
1205
1206   return h;
1207 }
1208
1209 //_____________________________________________________________________________
1210 AliMUONSparseHisto*
1211 AliMUONTrackerData::GetChannelSparseHisto(Int_t detElemId, Int_t manuId,
1212                                           Int_t manuChannel, Int_t dim)
1213 {
1214   /// Get histogram of a given channel. Create it if necessary
1215
1216   if (!fHistos) fHistos = new AliMUON2DMap(kTRUE);
1217
1218   AliMUON1DMap* m = static_cast<AliMUON1DMap*>(fHistos->FindObject(detElemId,manuId));
1219   if (!m)
1220   {
1221     m = new AliMUON1DMap(AliMpConstants::ManuNofChannels()); // start with only 1 dim
1222     m->SetUniqueID( ( manuId << 16 ) | detElemId );
1223     fHistos->Add(m);
1224   }
1225
1226   UInt_t uid = ( manuChannel << 16 ) | dim;
1227
1228   AliMUONSparseHisto* h = static_cast<AliMUONSparseHisto*>(m->FindObject(uid));
1229   if (!h)
1230   {
1231     h = new AliMUONSparseHisto(fXmin,fXmax);
1232
1233     h->SetUniqueID(uid);
1234
1235     m->Add(h);
1236   }
1237
1238   return h;
1239 }
1240
1241 //_____________________________________________________________________________
1242 void
1243 AliMUONTrackerData::GetDEManu(const AliMUONVCalibParam& param,
1244                               Int_t& detElemId, Int_t& manuId) const
1245 {
1246   /// Tries to get (detElemId,manuId) of param
1247
1248   // Load mapping manu store
1249   if ( ! AliMpCDB::LoadManuStore() ) {
1250     AliError("Could not access manu store from OCDB !");
1251     return;
1252   }
1253
1254   if ( param.ID1() <= 0 )
1255   {
1256     // we (probably) get a manu serial number
1257     Int_t serial = param.ID0();
1258     MpPair_t pair = AliMpManuStore::Instance()->GetDetElemIdManu(serial);
1259     detElemId = AliMp::PairFirst(pair);
1260     manuId = AliMp::PairSecond(pair);
1261     if ( !detElemId )
1262     {
1263       AliDebug(1,Form("DE %d manuId %d from serial %d is not correct !",
1264                       detElemId,manuId,serial));
1265     }
1266   }
1267   else
1268   {
1269     // we get a (de,manu) pair
1270     detElemId = param.ID0();
1271     manuId = param.ID1();
1272   }
1273 }
1274
1275
1276 //_____________________________________________________________________________
1277 Int_t
1278 AliMUONTrackerData::GetParts(AliMUONVCalibParam* external,
1279                              AliMUONVCalibParam*& chamber,
1280                              AliMUONVCalibParam*& de,
1281                              AliMUONVCalibParam*& busPatch,
1282                              AliMUONVCalibParam*& pcb,
1283                              AliMUONVCalibParam*& manu,
1284                              AliMUONVCalibParam*& channel,
1285                              AliMpDetElement*& mpde)
1286 {
1287   /// Get containers at all levels
1288
1289   chamber = de = busPatch = pcb = manu = channel = 0x0;
1290   mpde = 0x0;
1291
1292   AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
1293
1294   Int_t detElemId;
1295   Int_t manuId;
1296
1297   GetDEManu(*external,detElemId,manuId);
1298
1299   mpde = ddlStore->GetDetElement(detElemId,kFALSE);
1300
1301   if (!mpde) // can happen if reading e.g. capacitances store where we have data for non-connected manus
1302   {
1303     return -1;
1304   }
1305
1306   // explicitely check that de,manu is correct
1307   const AliMpVSegmentation* mpseg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId, manuId,kFALSE);
1308
1309   if (!mpseg)
1310   {
1311     return -1;
1312   }
1313
1314   Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
1315
1316   Int_t busPatchId = ddlStore->GetBusPatchId(detElemId,manuId);
1317
1318   if ( busPatchId <= 0 )
1319   {
1320     return -1;
1321   }
1322
1323   Int_t pcbIndex = -1;
1324
1325   AliMp::StationType stationType = mpde->GetStationType();
1326
1327   if ( stationType == AliMp::kStation345 )
1328   {
1329     AliMpDCSNamer namer("TRACKER");
1330     pcbIndex = namer.ManuId2PCBIndex(detElemId,manuId);
1331   }
1332
1333   if ( fIsChannelLevelEnabled )
1334   {
1335     channel = ChannelParam(detElemId,manuId,external);
1336   }
1337
1338   manu = ManuParam(detElemId,manuId,kTRUE);
1339
1340   busPatch = BusPatchParam(busPatchId,kTRUE);
1341
1342   de = DetectionElementParam(detElemId,kTRUE);
1343
1344   chamber = ChamberParam(chamberId,kTRUE);
1345
1346   pcb = 0x0;
1347
1348   if ( pcbIndex >= 0 )
1349   {
1350     pcb = PCBParam(detElemId,pcbIndex,kTRUE);
1351   }
1352
1353   return manuId;
1354 }
1355
1356 //_____________________________________________________________________________
1357 Bool_t
1358 AliMUONTrackerData::HasBusPatch(Int_t busPatchId) const
1359 {
1360   /// Whether we have data for a given buspatch
1361   return ( BusPatchParam(busPatchId) != 0 );
1362 }
1363
1364 //_____________________________________________________________________________
1365 Bool_t
1366 AliMUONTrackerData::HasChamber(Int_t chamberId) const
1367 {
1368   /// Whether we have data for a given chamber
1369   return ( ChamberParam(chamberId) != 0 );
1370 }
1371
1372 //_____________________________________________________________________________
1373 Bool_t
1374 AliMUONTrackerData::HasDetectionElement(Int_t detElemId) const
1375 {
1376   /// Whether we have data for a given detection element
1377   return ( DetectionElementParam(detElemId) != 0 );
1378 }
1379
1380 //_____________________________________________________________________________
1381 Bool_t
1382 AliMUONTrackerData::HasManu(Int_t detElemId, Int_t manuId) const
1383 {
1384   /// Whether we have data for a given manu
1385   return ( ManuParam(detElemId,manuId) != 0 );
1386 }
1387
1388 //_____________________________________________________________________________
1389 Bool_t
1390 AliMUONTrackerData::HasPCB(Int_t detElemId, Int_t pcbIndex) const
1391 {
1392   /// Whether we have data for a given pcb
1393   return ( PCBParam(detElemId,pcbIndex) != 0 );
1394 }
1395
1396 //_____________________________________________________________________________
1397 Double_t
1398 AliMUONTrackerData::Manu(Int_t detElemId, Int_t manuId, Int_t dim) const
1399 {
1400   /// Return the value for a given manu and a given dimension
1401
1402   AliMUONVCalibParam* param = ManuParam(detElemId,manuId);
1403   return param ? Value(*param,0,dim,DdlIdFromDetElemId(detElemId)) : 0.0;
1404 }
1405
1406 //_____________________________________________________________________________
1407 AliMUONVCalibParam*
1408 AliMUONTrackerData::ManuParam(Int_t detElemId, Int_t manuId, Bool_t create) const
1409 {
1410   /// Get the VCalibParam for a given manu
1411
1412   AliMUONVCalibParam* manu = fManuValues ? static_cast<AliMUONVCalibParam*>
1413     (fManuValues->FindObject(detElemId,manuId)) : 0x0 ;
1414
1415   if (!manu && create && fManuValues)
1416   {
1417     manu = CreateManuParam(detElemId,manuId);
1418     fManuValues->Add(manu);
1419   }
1420
1421   return manu;
1422 }
1423
1424 //_____________________________________________________________________________
1425 AliMUONVCalibParam*
1426 AliMUONTrackerData::CreateManuParam(Int_t detElemId, Int_t manuId) const
1427 {
1428   /// Create storage for one manu
1429
1430   AliCodeTimerAuto("",0);
1431
1432   AliMUONVCalibParam* manu = new AliMUONCalibParamND(Dimension(),1,detElemId,manuId,0.0);
1433
1434   // set the number of channels in that manu
1435
1436   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
1437
1438   manu->SetValueAsDouble(0,IndexOfNumberDimension(),de->NofChannelsInManu(manuId));
1439
1440   return manu;
1441 }
1442
1443 //_____________________________________________________________________________
1444 Long64_t
1445 AliMUONTrackerData::Merge(TCollection* list)
1446 {
1447   /// Merge this with a list of AliMUONVTrackerData
1448
1449   if (!list) return 0;
1450
1451   if ( list->IsEmpty() ) return NumberOfEvents(-1);
1452
1453   TIter next(list);
1454   const TObject* o(0x0);
1455
1456   while ( ( o = next() ) )
1457   {
1458     const AliMUONTrackerData* data = dynamic_cast<const AliMUONTrackerData*>(o);
1459     if (!o)
1460     {
1461       AliError(Form("Object named %s is not an AliMUONTrackerData ! Skipping it",
1462                     o->GetName()));
1463     }
1464     else
1465     {
1466       Bool_t ok = Add(*data);
1467       if (!ok)
1468       {
1469         AliError("Got incompatible objects");
1470       }
1471     }
1472   }
1473
1474   return NumberOfEvents(-1);
1475 }
1476
1477 //_____________________________________________________________________________
1478 Int_t
1479 AliMUONTrackerData::NumberOfDimensions() const
1480 {
1481   /// Number of dimensions we're dealing with
1482
1483   return fDimension + fgkVirtualExtraDimension;
1484 }
1485
1486 //_____________________________________________________________________________
1487 Int_t
1488 AliMUONTrackerData::NumberOfEvents(Int_t ddlNumber) const
1489 {
1490   /// Get the number of events we've seen for a given DDL, or the max
1491   /// in case ddlNumber<0
1492
1493   Int_t n(0);
1494
1495   if ( fNofEventsPerDDL && ddlNumber >= 0 && ddlNumber < fNofDDLs )
1496   {
1497     n = fNofEventsPerDDL[ddlNumber];
1498   }
1499   else
1500   {
1501     // get the max number of events
1502     return fNevents;
1503   }
1504
1505   return n;
1506 }
1507
1508 //_____________________________________________________________________________
1509 Double_t
1510 AliMUONTrackerData::PCB(Int_t detElemId, Int_t pcbIndex, Int_t dim) const
1511 {
1512   /// Return the value of a given pcb for a given dimension
1513
1514   AliMUONVCalibParam* param = PCBParam(detElemId,pcbIndex);
1515
1516   return param ? Value(*param,0,dim,DdlIdFromDetElemId(detElemId)) : 0.0;
1517 }
1518
1519 //_____________________________________________________________________________
1520 AliMUONVCalibParam*
1521 AliMUONTrackerData::PCBParam(Int_t detElemId, Int_t pcbIndex, Bool_t create) const
1522 {
1523   /// Return (if it exist) the VCalibParam for a given pcb
1524
1525   AliMUONVCalibParam* pcb =  fPCBValues ? static_cast<AliMUONVCalibParam*>
1526     (fPCBValues->FindObject(detElemId,pcbIndex)) : 0x0 ;
1527
1528   if (create && fPCBValues && !pcb)
1529   {
1530     pcb = CreatePCBParam(detElemId,pcbIndex);
1531     fPCBValues->Add(pcb);
1532   }
1533
1534   return pcb;
1535 }
1536
1537 //_____________________________________________________________________________
1538 AliMUONVCalibParam*
1539 AliMUONTrackerData::CreatePCBParam(Int_t detElemId, Int_t pcbIndex) const
1540 {
1541   /// Create storage for one PCB (station345 only)
1542
1543   AliCodeTimerAuto("",0);
1544
1545   AliMpDCSNamer namer("TRACKER");
1546
1547   AliMUONVCalibParam* pcb = new AliMUONCalibParamND(Dimension(),
1548                                                     namer.NumberOfPCBs(detElemId),
1549                                                     detElemId,
1550                                                     pcbIndex,
1551                                                     0.0);
1552   return pcb;
1553 }
1554
1555 //_____________________________________________________________________________
1556 void
1557 AliMUONTrackerData::Print(Option_t* wildcard, Option_t* opt) const
1558 {
1559   /// Printout
1560
1561   TNamed::Print(opt);
1562
1563   if ( !fIsSingleEvent )
1564   {
1565     for ( Int_t i = 0; i < fNofDDLs; ++i )
1566     {
1567       cout << Form("DDL %04d Nevents=%10d",AliDAQ::DdlID("MUONTRK",i),fNofEventsPerDDL[i]) << endl;
1568     }
1569   }
1570
1571         if ( !fIsChannelLevelEnabled )
1572         {
1573                 cout << "Is not storing data at the channel level" << endl;
1574         }
1575
1576   if ( !fIsManuLevelEnabled )
1577         {
1578                 cout << "Is not storing data at the manu level" << endl;
1579         }
1580
1581   for ( Int_t i = 0; i <= fExternalDimensionNames->GetLast(); ++i )
1582   {
1583     TObjString* name = static_cast<TObjString*>(fExternalDimensionNames->At(i));
1584     cout << Form("External Dimension %2d Name %s %s",i,
1585                  ( name ? name->String().Data() : "null"),
1586                  ( IsHistogrammed(i) ? "(histogrammed)" : "")) << endl;
1587   }
1588
1589   for ( Int_t i = 0; i <= fDimensionNames->GetLast(); ++i )
1590   {
1591     TObjString* name = static_cast<TObjString*>(fDimensionNames->At(i));
1592     cout << Form("Internal Dimension %2d Name %s",i,
1593                  ( name ? name->String().Data() : "null")) << endl;
1594   }
1595
1596   TString sopt(opt);
1597   sopt.ToUpper();
1598
1599   if ( sopt.Contains("CHANNEL") )
1600   {
1601     if ( fIsChannelLevelEnabled )
1602     {
1603       if ( fChannelValues ) fChannelValues->Print(wildcard,opt);
1604     }
1605     else
1606     {
1607       AliWarning("You requested channel values, but they were not stored !");
1608     }
1609   }
1610
1611   if ( sopt.Contains("MANU") )
1612   {
1613     if ( fIsManuLevelEnabled )
1614     {
1615       if ( fManuValues ) fManuValues->Print(wildcard,opt);
1616     }
1617     else
1618     {
1619       AliWarning("You requested manu values, but they were not stored !");
1620     }
1621   }
1622
1623   if ( sopt.Contains("BUSPATCH") && fBusPatchValues )
1624   {
1625     fBusPatchValues->Print(wildcard,opt);
1626   }
1627
1628   if ( sopt.Contains("DE") && fDEValues )
1629   {
1630     fDEValues->Print(wildcard,opt);
1631   }
1632
1633   if ( sopt.Contains("CHAMBER") && fChamberValues )
1634   {
1635     fChamberValues->Print(wildcard,opt);
1636   }
1637
1638 }
1639
1640 //_____________________________________________________________________________
1641 void
1642 AliMUONTrackerData::SetDimensionName(Int_t index, const char* name)
1643 {
1644   /// Set the name of a given dimension
1645
1646   if ( index >= fExternalDimension )
1647   {
1648     AliError(Form("%s : dimension %s : Index out of bounds : %d / %d",
1649                   GetName(),
1650                   name,index,fExternalDimension));
1651     return;
1652   }
1653
1654   Int_t ix = External2Internal(index);
1655
1656   if ( !IsSingleEvent() )
1657   {
1658     const char* prefix[] = { "mean", "sigma" };
1659
1660     for ( Int_t i = 0; i < 2; ++i )
1661     {
1662       Int_t j = ix+i;
1663
1664       SetInternalDimensionName(j,Form("%s of %s",prefix[i],name));
1665     }
1666   }
1667   else
1668   {
1669     SetInternalDimensionName(index,name);
1670   }
1671
1672   SetExternalDimensionName(index,name);
1673 }
1674
1675 //_____________________________________________________________________________
1676 void
1677 AliMUONTrackerData::MakeHistogramForDimension(Int_t index, Bool_t value, Double_t xmin, Double_t xmax)
1678 {
1679   /// decide to make histos for a given dimension
1680   if ( index >= ExternalDimension() )
1681   {
1682     AliError(Form("Index out of bounds : %d / %d",index,ExternalDimension()));
1683     return;
1684   }
1685
1686   AliWarning(Form("Will %s make histogram for data %s index %d : that might ressemble a memory leak depending on the input data",
1687                   value ? "":"not", GetName(),index));
1688   fHistogramming[index] = value;
1689   fXmin = xmin;
1690   fXmax = xmax;
1691 }
1692
1693 //_____________________________________________________________________________
1694 void
1695 AliMUONTrackerData::SetInternalDimensionName(Int_t index, const char* value)
1696 {
1697   /// Set the name of a given internal dimension
1698   if ( index >= fDimension )
1699   {
1700     AliError(Form("Index out of bounds : %d / %d",index,fDimension));
1701     return;
1702   }
1703
1704   TObjString* ovalue = static_cast<TObjString*>(fDimensionNames->At(index));
1705
1706   if ( ovalue )
1707   {
1708     fDimensionNames->Remove(ovalue);
1709     delete ovalue;
1710   }
1711   fDimensionNames->AddAt(new TObjString(value),index);
1712 }
1713
1714 //_____________________________________________________________________________
1715 void
1716 AliMUONTrackerData::SetExternalDimensionName(Int_t index, const char* value)
1717 {
1718   /// Set the name of a given external dimension
1719   if ( index >= fExternalDimension )
1720   {
1721     AliError(Form("Index out of bounds : %d / %d",index,fExternalDimension));
1722     return;
1723   }
1724
1725   TObjString* ovalue = static_cast<TObjString*>(fExternalDimensionNames->At(index));
1726
1727   if ( ovalue )
1728   {
1729     fExternalDimensionNames->Remove(ovalue);
1730     delete ovalue;
1731   }
1732   fExternalDimensionNames->AddAt(new TObjString(value),index);
1733 }
1734
1735 //_____________________________________________________________________________
1736 Double_t
1737 AliMUONTrackerData::Value(const AliMUONVCalibParam& param, Int_t i,
1738                           Int_t dim, Int_t ddlId) const
1739 {
1740   /// Compute the value for a given dim, using the internal information we have
1741   /// Basically we're converting sum of weights and sum of squares of weights
1742   /// into means and sigmas, and number of events into occupancy number.
1743
1744   Double_t n = param.ValueAsDouble(i,IndexOfNumberDimension());
1745
1746   if ( dim == IndexOfNumberDimension() ) return n; // the number of channels in any given element does not depend on the number of events
1747
1748   Double_t occ = param.ValueAsDouble(i,IndexOfOccupancyDimension());
1749
1750   if ( dim >= fDimension )
1751   {
1752     return occ;
1753   }
1754
1755   if ( dim == IndexOfOccupancyDimension() )
1756   {
1757     if ( ddlId < 0 ) AliError("Got a negative ddl id !");
1758     return occ/n/NumberOfEvents(ddlId);
1759   }
1760
1761   Double_t value = param.ValueAsDouble(i,dim);
1762
1763   if ( value >= AliMUONVCalibParam::InvalidFloatValue() ) return AliMUONVCalibParam::InvalidFloatValue();
1764
1765   if ( TMath::Even(dim) || IsSingleEvent() )
1766   {
1767                 Double_t x = value/occ;
1768
1769                 return ( TMath::Finite(x) ? x : 0.0 ) ;
1770   }
1771   else
1772   {
1773     Double_t nn = occ;
1774
1775     if ( nn > 1.0 )
1776     {
1777       Double_t mean = param.ValueAsDouble(i,dim-1)/nn;
1778
1779       return TMath::Sqrt(TMath::Abs((value-nn*mean*mean)/(nn-1.0)));
1780     }
1781     else
1782     {
1783       return 0.0;
1784     }
1785   }
1786
1787   AliError("Why am I here ?");
1788   return 0.0;
1789 }
1790
1791 //_____________________________________________________________________________
1792 void
1793 AliMUONTrackerData::Streamer(TBuffer &R__b)
1794 {
1795   /// Customized streamer
1796
1797   if (R__b.IsReading()) {
1798     AliMUONTrackerData::Class()->ReadBuffer(R__b, this);
1799     if ( !fNofDDLs )
1800     {
1801       // backward compatible mode : we set number of events
1802       // per DDL to the total number of events (the only information
1803       // we had before version 7 of that class)
1804       delete[] fNofEventsPerDDL;
1805       fNofDDLs=20;
1806       fNofEventsPerDDL = new Int_t[fNofDDLs];
1807       for ( Int_t i = 0; i < fNofDDLs; ++i )
1808       {
1809         fNofEventsPerDDL[i] = fNevents;
1810       }
1811     }
1812   }
1813   else {
1814     AliMUONTrackerData::Class()->WriteBuffer(R__b, this);
1815   }
1816 }
1817
1818 //_____________________________________________________________________________
1819 Bool_t
1820 AliMUONTrackerData::ExportAsASCIIOccupancyFile(const char* filename, Int_t runNumber) const
1821 {
1822   /// Export only the occupancy part, in a format compatible with what
1823   /// the online occupancy DA is writing
1824
1825   if ( ! AliMpDDLStore::Instance(kFALSE) )
1826   {
1827     AliError("Mapping not loaded. Cannot work");
1828     return kFALSE;
1829   }
1830
1831   if (!fManuValues)
1832   {
1833     AliError("No manu values. Cannot work");
1834     return kFALSE;
1835   }
1836
1837   ofstream out(filename);
1838
1839   if (out.bad())
1840   {
1841     AliError(Form("Cannot create file %s",filename));
1842     return kFALSE;
1843   }
1844
1845   out << "//===========================================================================" << endl;
1846   out << "//  Hit counter exported from $Id$" << endl;
1847   out << "//===========================================================================" << endl;
1848   out << "//" << endl;
1849   out << "//       * Run Number          : " << runNumber << endl;
1850   out << "//       * File Creation Date  : " << TTimeStamp().AsString("l") << endl;
1851   out << "//---------------------------------------------------------------------------" << endl;
1852   out << "//  BP   MANU  SUM_N  NEVENTS" << endl;
1853   out << "//---------------------------------------------------------------------------" << endl;
1854
1855   TIter next(fManuValues->CreateIterator());
1856   AliMUONVCalibParam* manu;
1857
1858   while ( ( manu = static_cast<AliMUONVCalibParam*>(next()) ) )
1859   {
1860     Int_t detElemId = manu->ID0();
1861     Int_t manuId = manu->ID1();
1862     Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
1863     Int_t ddl = AliMpDDLStore::Instance()->GetDDLfromBus( busPatchId);
1864     if ( busPatchId < 0 || ddl < 0 )
1865     {
1866       AliError(Form("Got invalid (DE,manu,bp,ddl)=(%d,%d,%d,%d). Skipping it",detElemId,manuId,busPatchId,ddl));
1867       continue;
1868     }
1869
1870     Int_t nevents = fNofEventsPerDDL[ddl];
1871
1872     out << Form("%5d %5d %10d %10d",busPatchId,manuId,manu->ValueAsInt(0,IndexOfOccupancyDimension()),nevents) << endl;
1873   }
1874
1875   out.close();
1876   return kTRUE;
1877 }
1878
1879