MUON/AliMUONTrackerConditionDataMaker.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 "AliMUONTrackerConditionDataMaker.h"
  19
  20 ///\class AliMUONTrackerConditionDataMaker
  21 ///
  22 /// Producer of AliMUONVTrackerData from OCDB or Ascii file condition data
  23 ///
  24 /// \author Laurent Aphecetche, Subatech
  25
  26 ///\cond CLASSIMP
  27 ClassImp(AliMUONTrackerConditionDataMaker)
  28 ///\endcond
  29
  30 #include "AliCDBManager.h"
  31 #include "AliCDBStorage.h"
  32 #include "AliDCSValue.h"
  33 #include "AliLog.h"
  34 #include "AliMpManuIterator.h"
  35 #include "AliMUON2DMap.h"
  36 #include "AliMUONCalibParamND.h"
  37 #include "AliMUONCalibParamNF.h"
  38 #include "AliMUONCalibParamNI.h"
  39 #include "AliMUONCalibrationData.h"
  40 #include "AliMUONDigitCalibrator.h"
  41 #include "AliMUONPadStatusMaker.h"
  42 #include "AliMUONPadStatusMapMaker.h"
  43 #include "AliMUONTrackerData.h"
  44 #include "AliMUONTrackerIO.h"
  45 #include "AliMpArrayI.h"
  46 #include "AliMpConstants.h"
  47 #include "AliMpDCSNamer.h"
  48 #include "AliMpDDLStore.h"
  49 #include "AliMpDEManager.h"
  50 #include "AliMpDetElement.h"
  51 #include "TClass.h"
  52 #include "TMap.h"
  53 #include "TObjString.h"
  54 #include "Riostream.h"
  55 #include "TString.h"
  56 #include <sstream>
  57 #include "TSystem.h"
  58
  59 //_____________________________________________________________________________
  60 AliMUONTrackerConditionDataMaker::AliMUONTrackerConditionDataMaker():
  61 AliMUONVTrackerDataMaker(),
  62 fData(0x0),
  63 fSource(""),
  64 fIsOwnerOfData(kTRUE)
  65 {
  66   /// default ctor to be able to stream
  67 }
  68
  69 //_____________________________________________________________________________
  70 AliMUONTrackerConditionDataMaker::AliMUONTrackerConditionDataMaker(Int_t runNumber, const char* ocdbPath, const char* type):
  71 AliMUONVTrackerDataMaker(),
  72 fData(0x0),
  73 fSource(Form("%s-%010d-%s",ocdbPath,runNumber,type)),
  74 fIsOwnerOfData(kTRUE)
  75 {
  76   /// ctor from OCDB
  77
  78   AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
  79
  80         AliCDBManager::Instance()->SetDefaultStorage(ocdbPath);
  81
  82   Int_t startOfValidity;
  83   AliMUONVStore* store = CreateStore(runNumber,ocdbPath,type,startOfValidity);
  84   AliDebug(1,Form("runNumber=%d ocdbPath=%s type=%s startOfValidity=%d store=%p",
  85                   runNumber,ocdbPath,type,startOfValidity,store));
  86   if ( store )
  87   {
  88     fData = CreateData(type,*store,startOfValidity);
  89   }
  90
  91   delete store;
  92
  93   AliCDBManager::Instance()->SetDefaultStorage(storage);
  94 }
  95
  96 //_____________________________________________________________________________
  97 AliMUONTrackerConditionDataMaker::AliMUONTrackerConditionDataMaker(const char* filename, const char* type):
  98 AliMUONVTrackerDataMaker(),
  99 fData(0x0),
 100 fSource(Form("%s-%s",filename,type)),
 101 fIsOwnerOfData(kTRUE)
 102 {
 103   /// ctor from an ASCII file
 104
 105   TString sFilename(gSystem->ExpandPathName(filename));
 106
 107   std::ifstream in(sFilename.Data());
 108   if (in.good())
 109   {
 110     std::ostringstream stream;
 111     char line[1024];
 112     while ( in.getline(line,1024) )
 113     {
 114       stream << line << "\n";
 115     }
 116
 117     in.close();
 118
 119     Int_t dummy;
 120
 121     AliMUONVStore* store = CreateStore(-1,stream.str().c_str(),type,dummy);
 122
 123     if ( store )
 124     {
 125       fData = CreateData(type,*store,dummy);
 126     }
 127     delete store;
 128   }
 129 }
 130
 131 //_____________________________________________________________________________
 132 AliMUONTrackerConditionDataMaker::AliMUONTrackerConditionDataMaker(const char* data, const char* type, Bool_t) :
 133 AliMUONVTrackerDataMaker(),
 134 fData(0x0),
 135 fSource(Form("direct-%s",type)),
 136 fIsOwnerOfData(kTRUE)
 137
 138 {
 139   /// ctor from a string containing the ASCII data
 140   /// the last parameter is there just to distinguish this ctor from the previous one
 141
 142   Int_t dummy;
 143
 144   AliMUONVStore* store = CreateStore(-1,data,type,dummy);
 145
 146   if ( store )
 147   {
 148     fData = CreateData(type,*store,dummy);
 149   }
 150   delete store;
 151
 152 }
 153
 154 //_____________________________________________________________________________
 155 AliMUONTrackerConditionDataMaker::~AliMUONTrackerConditionDataMaker()
 156 {
 157   /// dtor
 158   if ( fIsOwnerOfData ) delete fData;
 159 }
 160
 161
 162 //_____________________________________________________________________________
 163 AliMUONVTrackerData*
 164 AliMUONTrackerConditionDataMaker::CreateData(const char* type, AliMUONVStore& store, Int_t startOfValidity)
 165 {
 166   /// Create the data source
 167   AliMUONVTrackerData* data(0x0);
 168
 169   TString stype(type);
 170   stype.ToUpper();
 171
 172   if ( stype == "CAPACITANCES" )
 173   {
 174     data = new AliMUONTrackerData(Form("CAPA%d",startOfValidity),"Capacitances",2,kTRUE);
 175     data->SetDimensionName(0,"Capa");
 176     data->SetDimensionName(1,"Injection gain");
 177   }
 178   else if ( stype == "CONFIG" )
 179   {
 180     data = new AliMUONTrackerData(Form("CONFIG%d",startOfValidity),"Configuration",1);
 181     data->SetDimensionName(0,"there");
 182     data->DisableChannelLevel();
 183   }
 184   else if ( stype == "GAINS" )
 185   {
 186     data = new AliMUONTrackerData(Form("GAIN%d",startOfValidity),"Gains",7,kTRUE);
 187     data->SetDimensionName(0,"gain");
 188     data->SetDimensionName(1,"a1");
 189     data->SetDimensionName(2,"a2");
 190     data->SetDimensionName(3,"thres");
 191     data->SetDimensionName(4,"qual1");
 192     data->SetDimensionName(5,"qual2");
 193     data->SetDimensionName(6,"sat");
 194   }
 195   else if ( stype == "HV" )
 196   {
 197     data = new AliMUONTrackerData(Form("HV%d",startOfValidity),"High Voltages",1); //,!isSingleEvent);
 198                 data->SetDimensionName(0,"HV");
 199   }
 200   else if ( stype == "OCCUPANCY" )
 201   {
 202     data = new AliMUONTrackerData(Form("OCC%d",startOfValidity),"OccupancyMap",store);
 203     data->SetDimensionName(0,"One");
 204     return data; // important to return now to avoid the data->Add(store) later on...
 205   }
 206   else if ( stype == "PEDESTALS" )
 207   {
 208     data  = new AliMUONTrackerData(Form("PED%d",startOfValidity),"Pedestals",2,kTRUE);
 209     data->SetDimensionName(0,"Mean");
 210     data->SetDimensionName(1,"Sigma");
 211   }
 212   else if ( stype == "STATUS" )
 213   {
 214     data = new AliMUONTrackerData(Form("STATUS%d",startOfValidity),"Status",1,kTRUE);
 215     data->SetDimensionName(0,"Bits");
 216   }
 217   else if ( stype == "STATUSMAP" )
 218   {
 219     data = new AliMUONTrackerData(Form("STATUSMAP%d",startOfValidity),"Status map",2,kTRUE);
 220     data->SetDimensionName(0,"Bits");
 221     data->SetDimensionName(1,"Dead");
 222   }
 223
 224   if (!data)
 225   {
 226     AliErrorClass(Form("Could not create data for type=%s",type));
 227     return 0x0;
 228   }
 229
 230   data->Add(store);
 231
 232   return data;
 233 }
 234
 235 //_____________________________________________________________________________
 236 AliMUONVStore*
 237 AliMUONTrackerConditionDataMaker::CreateHVStore(TMap& m)
 238 {
 239   /// Create a store from hv values
 240
 241   AliMUONVStore* store = new AliMUON2DMap(kTRUE);
 242
 243   TIter next(&m);
 244   TObjString* s;
 245   AliMpDCSNamer hvNamer("TRACKER");
 246
 247   while ( ( s = static_cast<TObjString*>(next()) ) )
 248   {
 249     TString name(s->String());
 250
 251     Int_t hvIndex = hvNamer.DCSIndexFromDCSAlias(name.Data());
 252
 253     Int_t detElemId = hvNamer.DetElemIdFromDCSAlias(name.Data());
 254
 255     if ( hvIndex >= 0 && detElemId < 0 )
 256     {
 257       // skip switches
 258       continue;
 259     }
 260
 261     if ( !AliMpDEManager::IsValidDetElemId(detElemId) )
 262     {
 263       AliErrorClass(Form("Got an invalid DE = %d from alias = %s",
 264                          detElemId,name.Data()));
 265       continue;
 266     }
 267
 268     Int_t nPCBs = hvNamer.NumberOfPCBs(detElemId);
 269     Int_t indexMin = nPCBs ? 0 : hvIndex;
 270     Int_t indexMax = nPCBs ? nPCBs : hvIndex+1;
 271
 272     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
 273
 274     for ( int i = indexMin ; i < indexMax; ++i )
 275     {
 276       Float_t switchValue(1.0);
 277
 278       if ( nPCBs )
 279       {
 280         TString switchName(hvNamer.DCSSwitchName(detElemId,i));
 281
 282         TPair* p = static_cast<TPair*>(m.FindObject(switchName.Data()));
 283         TObjArray* a = static_cast<TObjArray*>(p->Value());
 284
 285         switchValue = AliMUONPadStatusMaker::SwitchValue(*a);
 286       }
 287
 288       const AliMpArrayI* manus = de->ManusForHV(i);
 289
 290       if (!manus) continue;
 291
 292       TPair* p = static_cast<TPair*>(m.FindObject(name.Data()));
 293       TObjArray* a = static_cast<TObjArray*>(p->Value());
 294       TIter n2(a);
 295       AliDCSValue* v;
 296       Float_t hvValue(0);
 297       Int_t n(0);
 298       while ( ( v = static_cast<AliDCSValue*>(n2()) ) )
 299       {
 300         hvValue += v->GetFloat();
 301         ++n;
 302       }
 303       hvValue *= switchValue;
 304
 305       if ( n ) hvValue /= n;
 306
 307       Int_t nofChannels(AliMpConstants::ManuNofChannels());
 308
 309       for ( Int_t k = 0 ; k < manus->GetSize(); ++k )
 310       {
 311         Int_t manuId = manus->GetValue(k);
 312         AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(store->FindObject(detElemId,manuId));
 313         if ( ! param )
 314         {
 315           param = new AliMUONCalibParamND(1,nofChannels,detElemId,manuId,0);
 316           store->Add(param);
 317         }
 318         for ( Int_t j = 0 ; j < nofChannels; ++j )
 319         {
 320           param->SetValueAsDouble(j,0,hvValue);
 321         }
 322       }
 323     }
 324   }
 325
 326   return store;
 327
 328 }
 329
 330 //_____________________________________________________________________________
 331 AliMUONVStore*
 332 AliMUONTrackerConditionDataMaker::CreateStatusStore(Int_t runNumber)
 333 {
 334   /// Get the status store
 335
 336   AliMUONDigitCalibrator calibrator(runNumber);
 337
 338   AliMUONVStore* sm = new AliMUON2DMap(kTRUE);
 339
 340   AliMpManuIterator it;
 341   Int_t detElemId, manuId;
 342
 343   while (it.Next(detElemId,manuId))
 344   {
 345     AliMUONVCalibParam* np = new AliMUONCalibParamNI(1,AliMpConstants::ManuNofChannels(),detElemId,manuId);
 346     for ( Int_t i = 0; i < np->Size(); ++i )
 347     {
 348       Int_t value = calibrator.PadStatus(detElemId,manuId,i);
 349       np->SetValueAsInt(i,0,value); // "raw" value of the status
 350     }
 351     sm->Add(np);
 352   }
 353
 354   return sm;
 355 }
 356
 357 //_____________________________________________________________________________
 358 AliMUONVStore*
 359 AliMUONTrackerConditionDataMaker::CreateStatusMapStore(Int_t runNumber)
 360 {
 361   /// Get the status map, and polish it a bit for representation purposes
 362
 363   AliMUONDigitCalibrator calibrator(runNumber);
 364
 365   AliMUONVStore* sm = new AliMUON2DMap(kTRUE);
 366
 367   AliMpManuIterator it;
 368   Int_t detElemId, manuId;
 369
 370   while (it.Next(detElemId,manuId))
 371   {
 372     AliMUONVCalibParam* np = new AliMUONCalibParamNI(2,AliMpConstants::ManuNofChannels(),detElemId,manuId);
 373     for ( Int_t i = 0; i < np->Size(); ++i )
 374     {
 375       Int_t value = calibrator.StatusMap(detElemId,manuId,i);
 376       Int_t channelIsDead = ( value & AliMUONPadStatusMapMaker::SelfDeadMask() );
 377       np->SetValueAsInt(i,0,value); // "raw" value of the status map
 378       np->SetValueAsInt(i,1,channelIsDead); // simple 0 or 1 for this channel
 379     }
 380     sm->Add(np);
 381   }
 382
 383   return sm;
 384 }
 385
 386 //_____________________________________________________________________________
 387 AliMUONVStore*
 388 AliMUONTrackerConditionDataMaker::CreateStore(Int_t runNumber,
 389                                               const char* source,
 390                                               const char* type,
 391                                               Int_t& startOfValidity)
 392 {
 393   /// Create the store by reading it from OCDB or from an ASCII file
 394
 395   TString stype(type);
 396   stype.ToUpper();
 397
 398   AliMUONVStore* store(0x0);
 399
 400   startOfValidity = 0;
 401
 402   Bool_t ocdb = (runNumber>=0);
 403
 404   if ( stype == "CAPACITANCES" )
 405   {
 406     if ( ocdb )
 407     {
 408       store = AliMUONCalibrationData::CreateCapacitances(runNumber,&startOfValidity);
 409     }
 410     else
 411     {
 412       store = new AliMUON2DMap(20000);
 413       AliMUONTrackerIO::DecodeCapacitances(source,*store);
 414     }
 415   }
 416   else if ( stype == "CONFIG" )
 417   {
 418     AliMUONVStore* tmp(0x0);
 419     if ( ocdb )
 420     {
 421       tmp = AliMUONCalibrationData::CreateConfig(runNumber,&startOfValidity);
 422     }
 423     else
 424     {
 425       tmp = new AliMUON2DMap(kTRUE);
 426       AliMUONTrackerIO::DecodeConfig(source,*tmp);
 427     }
 428     if ( tmp )
 429     {
 430       store = ExpandConfig(*tmp);
 431     }
 432     delete tmp;
 433   }
 434   else if ( stype == "GAINS" )
 435   {
 436     AliMUONVStore* gains(0x0);
 437     if ( ocdb )
 438     {
 439       gains = AliMUONCalibrationData::CreateGains(runNumber,&startOfValidity);
 440     }
 441     else
 442     {
 443       gains = new AliMUON2DMap(kTRUE);
 444       TString comment;
 445       AliMUONTrackerIO::DecodeGains(source,*gains,comment);
 446     }
 447     store = PatchGainStore(*gains);
 448     delete gains;
 449   }
 450   else if ( stype == "OCCUPANCY" )
 451   {
 452     if ( ocdb )
 453     {
 454       store = AliMUONCalibrationData::CreateOccupancyMap(runNumber,&startOfValidity);
 455     }
 456     else
 457     {
 458       store = new AliMUON2DMap(kTRUE);
 459       AliMUONTrackerIO::DecodeOccupancy(source,*store);
 460     }
 461   }
 462   else if ( stype == "PEDESTALS" )
 463   {
 464     if ( ocdb )
 465     {
 466       store = AliMUONCalibrationData::CreatePedestals(runNumber,&startOfValidity);
 467     }
 468     else
 469     {
 470       store = new AliMUON2DMap(kTRUE);
 471       AliMUONTrackerIO::DecodePedestals(source,*store);
 472     }
 473   }
 474
 475   /// Below are source that can only be accessed from OCDB
 476   if (!store && !ocdb)
 477   {
 478     return 0x0;
 479   }
 480
 481   if ( stype == "HV" )
 482   {
 483     TMap* m = AliMUONCalibrationData::CreateHV(runNumber,&startOfValidity);
 484                 store = CreateHVStore(*m);
 485     delete m;
 486   }
 487   else if ( stype == "STATUS" )
 488   {
 489     store = CreateStatusStore(runNumber);
 490   }
 491   else if ( stype == "STATUSMAP" )
 492   {
 493     store = CreateStatusMapStore(runNumber);
 494   }
 495
 496   return store;
 497 }
 498
 499 //_____________________________________________________________________________
 500 AliMUONVStore*
 501 AliMUONTrackerConditionDataMaker::ExpandConfig(const AliMUONVStore& manuConfig)
 502 {
 503   /// Convert the config from manu level to channel level (just to
 504   /// be able to add it correctly to the trackerdata...)
 505
 506   AliMUONVStore* store = manuConfig.Create();
 507
 508   TIter next(manuConfig.CreateIterator());
 509   AliMUONVCalibParam* p;
 510
 511   while ( ( p = static_cast<AliMUONVCalibParam*>(next()) ) )
 512   {
 513     AliMUONVCalibParam* c = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),p->ID0(),p->ID1(),0.0);
 514
 515     AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(p->ID0());
 516
 517     for ( Int_t i = 0; i < c->Size(); ++i )
 518     {
 519       if ( de->IsExistingChannel(p->ID1(),i) )
 520       {
 521         c->SetValueAsFloat(i,0,1.0);
 522       }
 523     }
 524
 525     store->Add(c);
 526   }
 527   return store;
 528 }
 529
 530 //_____________________________________________________________________________
 531 Long64_t
 532 AliMUONTrackerConditionDataMaker::Merge(TCollection*)
 533 {
 534   /// Merge
 535   AliError("Not implemented. Does it have sense ?");
 536   return 0;
 537 }
 538
 539 //_____________________________________________________________________________
 540 AliMUONVStore*
 541 AliMUONTrackerConditionDataMaker::PatchGainStore(const AliMUONVStore& gains)
 542 {
 543   /// Polish the gain store :
 544   /// a) adding a dimension, computed from a1, and called gain = 1/a1/0.2
 545   ///     where 0.2 is internal capa in pF, and gain is then in mV/fC
 546   /// b) splitting the quality in two
 547
 548   AliMUONVStore* store = gains.Create();
 549
 550   TIter next(gains.CreateIterator());
 551   AliMUONVCalibParam* param;
 552
 553   while ( ( param = static_cast<AliMUONVCalibParam*>(next()) ) )
 554   {
 555     AliMUONVCalibParam* nd = new AliMUONCalibParamND(param->Dimension()+2,
 556                                                      param->Size(),
 557                                                      param->ID0(),
 558                                                      param->ID1());
 559     for ( Int_t i = 0; i < param->Size(); ++i )
 560     {
 561
 562       Int_t qual = param->ValueAsInt(i,3);
 563                         Int_t q1 = (qual & 0xF0) >> 4;  // linear fit quality
 564                         Int_t q2 = qual & 0xF;          // parabolic fit quality
 565                         Double_t gain = 0.0;
 566
 567       if ( param->ValueAsFloat(i,0) > 1E-9 ) gain = 1.0/param->ValueAsFloat(i,0)/0.2;
 568
 569       nd->SetValueAsDouble(i,0,gain); // gain
 570       nd->SetValueAsDouble(i,1,param->ValueAsFloat(i,0)); // a1
 571       nd->SetValueAsDouble(i,2,param->ValueAsFloat(i,1)); // a2
 572       nd->SetValueAsInt(i,3,param->ValueAsInt(i,2)); // thres
 573       nd->SetValueAsInt(i,4,q1); // qual1
 574       nd->SetValueAsInt(i,5,q2); // qual2
 575       nd->SetValueAsInt(i,6,param->ValueAsInt(i,4)); // sat
 576     }
 577     store->Add(nd);
 578   }
 579
 580   return store;
 581 }
 582