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 "AliMUONCalibParamND.h"
  21 #include "AliMUONVStore.h"
  22 #include "AliMpBusPatch.h"
  23 #include "AliMpDDLStore.h"
  24 #include "AliMpDEManager.h"
  25 #include "AliMpDEIterator.h"
  26 #include "AliMpDetElement.h"
  27 #include "AliMpHVNamer.h"
  28 #include "AliCodeTimer.h"
  29 #include "AliLog.h"
  30 #include <Riostream.h>
  31 #include <TMath.h>
  32 #include <TObjArray.h>
  33 #include <TObjString.h>
  34 #include <TString.h>
  35 #include <TVector2.h>
  36 #include <float.h>
  37
  38 /// \class AliMUONTrackerData
  39 ///
  40 /// Implementation of AliMUONVTrackerData class
  41 ///
  42 /// \author Laurent Aphecetche, Subatech
  43
  44 ///\cond CLASSIMP
  45 ClassImp(AliMUONTrackerData)
  46 ///\endcond
  47
  48 const Int_t AliMUONTrackerData::fgkExtraDimension = 2;
  49 const Int_t AliMUONTrackerData::fgkVirtualExtraDimension = 1;
  50
  51 //_____________________________________________________________________________
  52 AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title,
  53                                        Int_t dimension,
  54                                        Bool_t runnable)
  55 : AliMUONVTrackerData(name,title),
  56 fChannelValues(0x0),
  57 fManuValues(0x0),
  58 fBusPatchValues(0x0),
  59 fDEValues(0x0),
  60 fChamberValues(0x0),
  61 fPCBValues(0x0),
  62 fDimension(dimension*2+fgkExtraDimension),
  63 fNevents(0x0),
  64 fDimensionNames(new TObjArray(fDimension+fgkVirtualExtraDimension)),
  65 fExternalDimension(dimension),
  66 fIsRunnable(runnable)
  67 {
  68   /// ctor
  69   fDimensionNames->SetOwner(kTRUE);
  70   fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
  71   fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
  72   fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
  73   Clear();
  74 }
  75
  76 //_____________________________________________________________________________
  77 AliMUONTrackerData::~AliMUONTrackerData()
  78 {
  79   /// dtor
  80   delete fChannelValues;
  81   delete fManuValues;
  82   delete fBusPatchValues;
  83   delete fDEValues;
  84   delete fChamberValues;
  85   delete fPCBValues;
  86   delete fDimensionNames;
  87 }
  88
  89 //_____________________________________________________________________________
  90 Bool_t
  91 AliMUONTrackerData::Add(const AliMUONVStore& store)
  92 {
  93   /// We first convert the external store to a temporary internal store
  94   /// with more dimension (2*store's dimension)
  95
  96   AliCodeTimerAuto(GetName())
  97
  98   Int_t ndim(NumberOfDimensions()-fgkExtraDimension-fgkVirtualExtraDimension);
  99
 100   AliMUONVStore* istore = store.Create();
 101
 102   TIter next(store.CreateIterator());
 103   AliMUONVCalibParam* external;
 104
 105   AliCodeTimerStart("from external to internal store");
 106
 107   while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
 108   {
 109     Int_t detElemId = external->ID0();
 110     Int_t manuId = external->ID1();
 111
 112     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 113
 114     AliMUONVCalibParam* internal = static_cast<AliMUONVCalibParam*>
 115       (istore->FindObject(detElemId,manuId));
 116
 117     if (!internal)
 118     {
 119       internal = new AliMUONCalibParamND(ndim,external->Size(),
 120                                          detElemId, manuId,
 121                                          0.0);
 122       istore->Add(internal);
 123     }
 124
 125     for ( Int_t i = 0; i < external->Size(); ++i )
 126     {
 127       Bool_t connectPad = de->IsConnectedChannel(manuId,i);
 128
 129       if (!connectPad) continue;
 130
 131       for ( Int_t j = 0; j < external->Dimension(); ++j )
 132       {
 133         Int_t ix = External2Internal(j);
 134
 135         Double_t vext = external->IsDoublePrecision() ?
 136           external->ValueAsDouble(i,j) :
 137           external->ValueAsFloat(i,j);
 138
 139         Double_t sumw = internal->ValueAsDouble(i,ix) + vext;
 140         Double_t sumw2 = internal->ValueAsDouble(i,ix+1) + vext*vext;
 141
 142         internal->SetValueAsFloat(i,ix,sumw);
 143         internal->SetValueAsFloat(i,ix+1,sumw2);
 144       }
 145     }
 146   }
 147
 148   AliCodeTimerStop("from external to internal store");
 149
 150   /// and we add this internal store to what we already have
 151
 152   InternalAdd(*istore);
 153
 154   /// delete the temporary internal store.
 155   AliCodeTimerStart("delete");
 156   delete istore;
 157   AliCodeTimerStop("delete");
 158
 159   return kTRUE;
 160 }
 161
 162 //_____________________________________________________________________________
 163 Double_t
 164 AliMUONTrackerData::BusPatch(Int_t busPatchId, Int_t dim) const
 165 {
 166   /// Return the value of a given buspatch for a given dimension
 167   /// or 0 if not existing
 168   AliMUONVCalibParam* param = BusPatchParam(busPatchId);
 169   return param ? Value(*param,0,dim) : 0.0;
 170 }
 171
 172 //_____________________________________________________________________________
 173 AliMUONVCalibParam*
 174 AliMUONTrackerData::BusPatchParam(Int_t busPatchId) const
 175 {
 176   /// Return (if it exist), the VCalibParam for a given busPatch
 177   return fBusPatchValues ? static_cast<AliMUONVCalibParam*>
 178   (fBusPatchValues->FindObject(busPatchId)) : 0x0;
 179 }
 180
 181 //_____________________________________________________________________________
 182 Double_t
 183 AliMUONTrackerData::Chamber(Int_t chamberId, Int_t dim) const
 184 {
 185   /// Return the value fo a given chamber for a given dimension,
 186   /// or zero if not existing
 187   AliMUONVCalibParam* param = ChamberParam(chamberId);
 188   return param ? Value(*param,0,dim) : 0.0;
 189 }
 190
 191 //_____________________________________________________________________________
 192 AliMUONVCalibParam*
 193 AliMUONTrackerData::ChamberParam(Int_t chamberId) const
 194 {
 195   /// Return (if it exist) the VCalibParam for a given chamber
 196   return fChamberValues ? static_cast<AliMUONVCalibParam*>
 197   (fChamberValues->FindObject(chamberId)) : 0x0;
 198 }
 199
 200 //_____________________________________________________________________________
 201 Double_t
 202 AliMUONTrackerData::Channel(Int_t detElemId, Int_t manuId,
 203                             Int_t manuChannel, Int_t dim) const
 204 {
 205   /// Return the value for a given channel for a given dimension
 206
 207   AliMUONVCalibParam* param = ChannelParam(detElemId,manuId);
 208
 209   return param ? Value(*param,manuChannel,dim) : 0.0;
 210 }
 211
 212 //_____________________________________________________________________________
 213 AliMUONVCalibParam*
 214 AliMUONTrackerData::ChannelParam(Int_t detElemId, Int_t manuId) const
 215 {
 216   /// Return (if it exist) the VCalibParam for a given manu
 217   return fChannelValues ? static_cast<AliMUONVCalibParam*>
 218   (fChannelValues->FindObject(detElemId,manuId)) : 0x0 ;
 219 }
 220
 221
 222 //_____________________________________________________________________________
 223 void
 224 AliMUONTrackerData::Clear(Option_t*)
 225 {
 226   /// Clear all the values
 227   if ( fChannelValues ) fChannelValues->Clear();
 228   if ( fManuValues ) fManuValues->Clear();
 229   if ( fBusPatchValues) fBusPatchValues->Clear();
 230   if ( fPCBValues ) fPCBValues->Clear();
 231   if ( fDEValues) fDEValues->Clear();
 232   if ( fChamberValues) fChamberValues->Clear();
 233   fNevents = 0;
 234   NumberOfEventsChanged();
 235 }
 236
 237 //_____________________________________________________________________________
 238 Double_t
 239 AliMUONTrackerData::Count(Int_t detElemId, Int_t manuId,
 240                           Int_t manuChannel) const
 241 {
 242   /// Return the number of times a given channel had data
 243   AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>
 244   (fChannelValues->FindObject(detElemId,manuId));
 245
 246   if ( !param ) return 0.0;
 247
 248   return param->ValueAsDouble(manuChannel,IndexOfOccupancyDimension());
 249 }
 250
 251 //_____________________________________________________________________________
 252 AliMUONVCalibParam*
 253 AliMUONTrackerData::CreateDouble(const AliMUONVCalibParam& param) const
 254 {
 255   /// Create a double version of VCalibParam, for internal use
 256   AliMUONVCalibParam* c = new AliMUONCalibParamND(param.Dimension()+fgkExtraDimension,
 257                                  param.Size(),
 258                                  param.ID0(),
 259                                  param.ID1(),
 260                                  0.0);
 261
 262   for ( Int_t i = 0; i < c->Size(); ++i )
 263   {
 264     c->SetValueAsDouble(i,IndexOfNumberDimension(),1.0);
 265   }
 266
 267   return c;
 268 }
 269
 270 //_____________________________________________________________________________
 271 Double_t
 272 AliMUONTrackerData::DetectionElement(Int_t detElemId, Int_t dim) const
 273 {
 274   /// Return the value for a given detection element for a given dimension
 275   AliMUONVCalibParam* param = DetectionElementParam(detElemId);
 276   return param ? Value(*param,0,dim) : 0.0;
 277
 278 }
 279
 280 //_____________________________________________________________________________
 281 AliMUONVCalibParam*
 282 AliMUONTrackerData::DetectionElementParam(Int_t detElemId) const
 283 {
 284   /// Return (if it exist) the VCalibParam for a given detection element
 285   return fDEValues ? static_cast<AliMUONVCalibParam*>
 286   (fDEValues->FindObject(detElemId)) : 0x0 ;
 287 }
 288
 289 //_____________________________________________________________________________
 290 TString
 291 AliMUONTrackerData::DimensionName(Int_t dim) const
 292 {
 293   /// Get the name of a given dimension
 294   TObjString* value = static_cast<TObjString*>(fDimensionNames->At(dim));
 295   if ( value )
 296   {
 297     return value->String();
 298   }
 299   else
 300   {
 301     return TString("Invalid");
 302   }
 303 }
 304
 305 //_____________________________________________________________________________
 306 Bool_t
 307 AliMUONTrackerData::HasBusPatch(Int_t busPatchId) const
 308 {
 309   /// Whether we have data for a given buspatch
 310   return ( BusPatchParam(busPatchId) != 0 );
 311 }
 312
 313 //_____________________________________________________________________________
 314 Bool_t
 315 AliMUONTrackerData::HasChamber(Int_t chamberId) const
 316 {
 317   /// Whether we have data for a given chamber
 318   return ( ChamberParam(chamberId) != 0 );
 319 }
 320
 321 //_____________________________________________________________________________
 322 Bool_t
 323 AliMUONTrackerData::HasDetectionElement(Int_t detElemId) const
 324 {
 325   /// Whether we have data for a given detection element
 326   return ( DetectionElementParam(detElemId) != 0 );
 327 }
 328
 329 //_____________________________________________________________________________
 330 Bool_t
 331 AliMUONTrackerData::HasManu(Int_t detElemId, Int_t manuId) const
 332 {
 333   /// Whether we have data for a given manu
 334   return ( ManuParam(detElemId,manuId) != 0 );
 335 }
 336
 337 //_____________________________________________________________________________
 338 Bool_t
 339 AliMUONTrackerData::HasPCB(Int_t detElemId, Int_t pcbIndex) const
 340 {
 341   /// Whether we have data for a given pcb
 342   return ( PCBParam(detElemId,pcbIndex) != 0 );
 343 }
 344
 345 //_____________________________________________________________________________
 346 Bool_t
 347 AliMUONTrackerData::InternalAdd(const AliMUONVStore& store)
 348 {
 349   /// Add the given store to our internal store
 350   /// Store must be of dimension = fDimension-1
 351
 352   AliCodeTimerAuto(GetName());
 353
 354   AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
 355
 356   ++fNevents;
 357   NumberOfEventsChanged();
 358
 359   if (!fChannelValues)
 360   {
 361     fChannelValues = store.Create();
 362     fManuValues = store.Create();
 363     fBusPatchValues = store.Create();
 364     fDEValues = store.Create();
 365     fChamberValues = store.Create();
 366     fPCBValues = store.Create();
 367   }
 368
 369   TIter next(store.CreateIterator());
 370   AliMUONVCalibParam* external;
 371
 372   AliMpHVNamer namer;
 373
 374   while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
 375   {
 376     if ( external->Dimension() != fDimension-fgkExtraDimension )
 377     {
 378       AliError(Form("Incompatible dimensions %d vs %d",
 379                     external->Dimension(),fDimension-fgkExtraDimension));
 380       return kFALSE;
 381     }
 382
 383     Int_t detElemId = external->ID0();
 384
 385     AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
 386
 387     Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
 388
 389     Int_t manuId = external->ID1();
 390
 391     AliMpDetElement* mpde = ddlStore->GetDetElement(detElemId);
 392
 393     Int_t busPatchId = ddlStore->GetBusPatchId(detElemId,manuId);
 394
 395     Int_t pcbIndex = -1;
 396
 397     if ( stationType == AliMp::kStation345 )
 398     {
 399       pcbIndex = namer.ManuId2PCBIndex(detElemId,manuId);
 400     }
 401
 402     AliMUONVCalibParam* channel = ChannelParam(detElemId,manuId);
 403     if (!channel)
 404     {
 405       channel = CreateDouble(*external);
 406       fChannelValues->Add(channel);
 407     }
 408
 409     AliMUONVCalibParam* manu = ManuParam(detElemId,manuId);
 410     if (!manu)
 411     {
 412       manu = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension,
 413                                      1,
 414                                      detElemId,
 415                                      manuId,
 416                                      0.0);
 417
 418       // set the number of channels in that manu
 419
 420       AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 421
 422       manu->SetValueAsDouble(0,IndexOfNumberDimension(),de->NofChannelsInManu(manuId));
 423
 424       fManuValues->Add(manu);
 425     }
 426
 427     AliMUONVCalibParam* busPatch = BusPatchParam(busPatchId);
 428     if (!busPatch)
 429     {
 430       AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
 431
 432       if (!bp)
 433       {
 434         AliError(Form("Got an invalid buspatchId = %d",busPatchId));
 435         continue;
 436       }
 437
 438       busPatch = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension,
 439                                          1,
 440                                          busPatchId,
 441                                          0,
 442                                          0.0);
 443
 444       // set the number of channels in that buspatch
 445
 446       Int_t nchannels(0);
 447
 448       AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 449
 450       for ( Int_t i = 0; i < bp->GetNofManus(); ++i )
 451       {
 452         Int_t manuId = bp->GetManuId(i);
 453         nchannels += de->NofChannelsInManu(manuId);
 454       }
 455
 456       busPatch->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels);
 457
 458       fBusPatchValues->Add(busPatch);
 459     }
 460
 461     AliMUONVCalibParam* de = DetectionElementParam(detElemId);
 462     if (!de)
 463     {
 464       de = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension,
 465                                          1,
 466                                          detElemId,
 467                                          0,
 468                                          0.0);
 469
 470       AliMpDetElement* det = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 471       Int_t nchannels(0);
 472
 473       for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i )
 474       {
 475         Int_t busPatchId = det->GetBusPatchId(i);
 476         AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
 477         for ( Int_t j = 0; j < bp->GetNofManus(); ++j )
 478         {
 479           Int_t manuId = bp->GetManuId(j);
 480           nchannels += det->NofChannelsInManu(manuId);
 481         }
 482       }
 483
 484       de->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels);
 485
 486       fDEValues->Add(de);
 487     }
 488
 489     AliMUONVCalibParam* chamber = ChamberParam(chamberId);
 490     if (!chamber)
 491     {
 492       chamber = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension,
 493                                    1,
 494                                    chamberId,
 495                                    0,
 496                                    0.0);
 497
 498       // set the number of channels in that chamber
 499
 500       Int_t nchannels(0);
 501
 502       AliMpDEIterator it;
 503
 504       it.First(chamberId);
 505
 506       while ( !it.IsDone() )
 507       {
 508         AliMpDetElement* det = it.CurrentDE();
 509
 510         for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i )
 511         {
 512           Int_t busPatchId = det->GetBusPatchId(i);
 513           AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
 514           for ( Int_t j = 0; j < bp->GetNofManus(); ++j )
 515           {
 516             Int_t manuId = bp->GetManuId(j);
 517             nchannels += det->NofChannelsInManu(manuId);
 518           }
 519         }
 520
 521         it.Next();
 522       }
 523
 524       chamber->SetValueAsDouble(0,IndexOfNumberDimension(),nchannels);
 525
 526       fChamberValues->Add(chamber);
 527     }
 528
 529     AliMUONVCalibParam* pcb = 0x0;
 530
 531     if ( pcbIndex >= 0 )
 532     {
 533       pcb = PCBParam(detElemId,pcbIndex);
 534       if (!pcb)
 535       {
 536         pcb = new AliMUONCalibParamND(external->Dimension()+fgkExtraDimension,
 537                                         namer.NumberOfPCBs(detElemId),
 538                                         detElemId,
 539                                         pcbIndex,
 540                                         0.0);
 541         fPCBValues->Add(pcb);
 542       }
 543     }
 544
 545     for ( Int_t i = 0; i < external->Size(); ++i )
 546     {
 547       Bool_t existingChannel = mpde->IsConnectedChannel(manuId,i);
 548
 549       if ( existingChannel )
 550       {
 551         Bool_t validChannel(kFALSE);
 552
 553         for ( Int_t j = 0; j < external->Dimension(); ++j )
 554         {
 555           if ( external->ValueAsFloat(i,j) >= AliMUONVCalibParam::InvalidFloatValue() ) continue;
 556
 557           validChannel = kTRUE;
 558
 559           Double_t vext = external->IsDoublePrecision() ?
 560             external->ValueAsDouble(i,j) :
 561             external->ValueAsFloat(i,j);
 562
 563           Double_t value = channel->ValueAsDouble(i,j) + vext;
 564
 565           channel->SetValueAsDouble(i,j,value);
 566
 567           manu->SetValueAsDouble(0,j,manu->ValueAsDouble(0,j)+vext);
 568
 569           busPatch->SetValueAsDouble(0,j,busPatch->ValueAsDouble(0,j)+vext);
 570
 571           de->SetValueAsDouble(0,j,de->ValueAsDouble(0,j)+vext);
 572
 573           chamber->SetValueAsDouble(0,j,chamber->ValueAsDouble(0,j)+vext);
 574
 575           if ( pcb )
 576           {
 577             pcb->SetValueAsDouble(pcbIndex,j,pcb->ValueAsDouble(pcbIndex,j)+vext);
 578           }
 579         }
 580
 581         if ( validChannel )
 582         {
 583           channel->SetValueAsDouble(i,IndexOfOccupancyDimension(),
 584                                   channel->ValueAsDouble(i,IndexOfOccupancyDimension())+1.0);
 585           manu->SetValueAsDouble(0,IndexOfOccupancyDimension(),
 586                                manu->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0);
 587           busPatch->SetValueAsDouble(0,IndexOfOccupancyDimension(),
 588                                  busPatch->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0);
 589           de->SetValueAsDouble(0,IndexOfOccupancyDimension(),
 590                                      de->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0);
 591           chamber->SetValueAsDouble(0,IndexOfOccupancyDimension(),
 592                                chamber->ValueAsDouble(0,IndexOfOccupancyDimension())+1.0);
 593           if ( pcb )
 594           {
 595             pcb->SetValueAsDouble(pcbIndex,IndexOfOccupancyDimension(),
 596                                     pcb->ValueAsDouble(pcbIndex,IndexOfOccupancyDimension())+1.0);
 597           }
 598         }
 599       }
 600     }
 601   }
 602
 603   return kTRUE;
 604 }
 605
 606 //_____________________________________________________________________________
 607 Double_t
 608 AliMUONTrackerData::Manu(Int_t detElemId, Int_t manuId, Int_t dim) const
 609 {
 610   /// Return the value for a given manu and a given dimension
 611
 612   AliMUONVCalibParam* param = ManuParam(detElemId,manuId);
 613   return param ? Value(*param,0,dim) : 0.0;
 614 }
 615
 616 //_____________________________________________________________________________
 617 AliMUONVCalibParam*
 618 AliMUONTrackerData::ManuParam(Int_t detElemId, Int_t manuId) const
 619 {
 620   /// Get the VCalibParam for a given manu
 621   return fManuValues ? static_cast<AliMUONVCalibParam*>
 622   (fManuValues->FindObject(detElemId,manuId)) : 0x0 ;
 623 }
 624
 625 //_____________________________________________________________________________
 626 Int_t
 627 AliMUONTrackerData::NumberOfDimensions() const
 628 {
 629   /// Number of dimensions we're dealing with
 630
 631   return fDimension + fgkVirtualExtraDimension;
 632 }
 633
 634 //_____________________________________________________________________________
 635 Double_t
 636 AliMUONTrackerData::PCB(Int_t detElemId, Int_t pcbIndex, Int_t dim) const
 637 {
 638   /// Return the value of a given pcb for a given dimension
 639
 640   AliMUONVCalibParam* param = PCBParam(detElemId,pcbIndex);
 641
 642   return param ? Value(*param,pcbIndex,dim) : 0.0;
 643 }
 644
 645 //_____________________________________________________________________________
 646 AliMUONVCalibParam*
 647 AliMUONTrackerData::PCBParam(Int_t detElemId, Int_t pcbIndex) const
 648 {
 649   /// Return (if it exist) the VCalibParam for a given pcb
 650   return fPCBValues ? static_cast<AliMUONVCalibParam*>
 651   (fPCBValues->FindObject(detElemId,pcbIndex)) : 0x0 ;
 652 }
 653
 654 //_____________________________________________________________________________
 655 void
 656 AliMUONTrackerData::Print(Option_t* wildcard, Option_t* opt) const
 657 {
 658   /// Printout
 659
 660   TNamed::Print(opt);
 661
 662   if ( fIsRunnable )
 663   {
 664     cout << " Nevents=" << fNevents << endl;
 665   }
 666
 667   for ( Int_t i = 0; i <= fDimensionNames->GetLast(); ++i )
 668   {
 669     TObjString* name = static_cast<TObjString*>(fDimensionNames->At(i));
 670     cout << Form("Dimension %2d Name %s",i,
 671                  ( name ? name->String().Data() : "null")) << endl;
 672   }
 673
 674   cout << Form("External Dimensions = %d",fExternalDimension) << endl;
 675
 676   TString sopt(opt);
 677   sopt.ToUpper();
 678
 679   if ( sopt.Contains("CHANNEL") && fChannelValues )
 680   {
 681     fChannelValues->Print(wildcard,opt);
 682   }
 683
 684   if ( sopt.Contains("MANU") && fManuValues )
 685   {
 686     fManuValues->Print(wildcard,opt);
 687   }
 688
 689   if ( sopt.Contains("BUSPATCH") && fBusPatchValues )
 690   {
 691     fBusPatchValues->Print(wildcard,opt);
 692   }
 693
 694   if ( sopt.Contains("DE") && fDEValues )
 695   {
 696     fDEValues->Print(wildcard,opt);
 697   }
 698
 699   if ( sopt.Contains("CHAMBER") && fChamberValues )
 700   {
 701     fChamberValues->Print(wildcard,opt);
 702   }
 703
 704 }
 705
 706 //_____________________________________________________________________________
 707 void
 708 AliMUONTrackerData::SetDimensionName(Int_t index, const char* name)
 709 {
 710   /// Set the name of a given dimension
 711
 712   if ( index >= fExternalDimension )
 713   {
 714     AliError(Form("Index out of bounds : %d / %d",index,fExternalDimension));
 715     return;
 716   }
 717
 718   Int_t ix = External2Internal(index);
 719
 720   const char* prefix[] = { "mean", "sigma" };
 721
 722   for ( Int_t i = 0; i < 2; ++i )
 723   {
 724     Int_t j = ix+i;
 725
 726     SetInternalDimensionName(j,Form("%s of %s",prefix[i],name));
 727   }
 728 }
 729
 730 //_____________________________________________________________________________
 731 void
 732 AliMUONTrackerData::SetInternalDimensionName(Int_t index, const char* value)
 733 {
 734   /// Set the name of a given internal dimension
 735   if ( index >= fDimension )
 736   {
 737     AliError(Form("Index out of bounds : %d / %d",index,fDimension));
 738     return;
 739   }
 740
 741   TObjString* ovalue = static_cast<TObjString*>(fDimensionNames->At(index));
 742
 743   if ( ovalue )
 744   {
 745     fDimensionNames->Remove(ovalue);
 746     delete ovalue;
 747   }
 748   fDimensionNames->AddAt(new TObjString(value),index);
 749 }
 750
 751 //_____________________________________________________________________________
 752 Double_t
 753 AliMUONTrackerData::Value(const AliMUONVCalibParam& param, Int_t i, Int_t dim) const
 754 {
 755   /// Compute the value for a given dim, using the internal information we have
 756   /// Basically we're converting sum of weights and sum of squares of weights
 757   /// into means and sigmas, and number of events into occupancy number.
 758
 759   Double_t n = param.ValueAsDouble(i,IndexOfNumberDimension());
 760
 761   if ( dim == IndexOfNumberDimension() ) return n; // the number of channels in any given element does not depend on the number of events
 762
 763   Double_t occ = param.ValueAsDouble(i,IndexOfOccupancyDimension());
 764
 765   if ( dim >= fDimension )
 766   {
 767     return occ;
 768   }
 769
 770   if ( dim == IndexOfOccupancyDimension() ) return occ/n/NumberOfEvents();
 771
 772   Double_t value = param.ValueAsDouble(i,dim);
 773
 774   if ( value >= AliMUONVCalibParam::InvalidFloatValue() ) return AliMUONVCalibParam::InvalidFloatValue();
 775
 776   if ( TMath::Even(dim) )
 777   {
 778     return value/occ;
 779   }
 780   else
 781   {
 782     Double_t sumw = param.ValueAsDouble(i,dim-1);
 783     Double_t mean = sumw/n;
 784
 785     return  TMath::Sqrt(TMath::Abs(value/occ - mean*mean));
 786   }
 787
 788   AliError("Why am I here ?");
 789   return 0.0;
 790 }
 791