AliRoot Core  v5-06-30 (35d6c57)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliMUONTrackerConditionDataMaker.cxx
Go to the documentation of this file.
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 
19 
25 
29 
30 #include "AliCDBManager.h"
31 #include "AliCDBStorage.h"
32 #include "AliDCSValue.h"
33 #include "AliLog.h"
34 #include "AliMpArrayI.h"
35 #include "AliMpConstants.h"
36 #include "AliMpDCSNamer.h"
37 #include "AliMpDDLStore.h"
38 #include "AliMpDEManager.h"
39 #include "AliMpDetElement.h"
40 #include "AliMpManuIterator.h"
41 #include "AliMUON2DMap.h"
42 #include "AliMUONCalibParamND.h"
43 #include "AliMUONCalibParamNF.h"
44 #include "AliMUONCalibParamNI.h"
45 #include "AliMUONCalibrationData.h"
46 #include "AliMUONDigitCalibrator.h"
47 #include "AliMUONPadStatusMaker.h"
49 #include "AliMUONRejectList.h"
50 #include "AliMUONTrackerData.h"
52 #include "AliMUONTrackerIO.h"
53 #include "Riostream.h"
54 #include "TClass.h"
55 #include "TMap.h"
56 #include "TObjString.h"
57 #include "TString.h"
58 #include "TSystem.h"
59 #include <sstream>
60 
61 //_____________________________________________________________________________
64 fData(0x0),
65 fSource(""),
66 fIsOwnerOfData(kTRUE)
67 {
69 }
70 
71 //_____________________________________________________________________________
72 AliMUONTrackerConditionDataMaker::AliMUONTrackerConditionDataMaker(Int_t runNumber, const char* ocdbPath, const char* type):
74 fData(0x0),
75 fSource(Form("%s-%010d-%s",ocdbPath,runNumber,type)),
76 fIsOwnerOfData(kTRUE)
77 {
79 
80  AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
81 
82  AliCDBManager::Instance()->SetDefaultStorage(ocdbPath);
83 
84  Int_t startOfValidity;
85 
87  {
88  AliMUONRejectList* rl = AliMUONCalibrationData::CreateRejectList(runNumber,&startOfValidity);
89 
90  if (rl)
91  {
92  fData = new AliMUONTrackerData(Form("RL%d",startOfValidity),"RejectList",*rl);
93  }
94 
95  delete rl;
96  }
97  else
98  {
99  AliMUONVStore* store = CreateStore(runNumber,ocdbPath,type,startOfValidity);
100 
101  AliDebug(1,Form("runNumber=%d ocdbPath=%s type=%s startOfValidity=%d store=%p",
102  runNumber,ocdbPath,type,startOfValidity,store));
103  if ( store )
104  {
105  fData = CreateData(type,*store,startOfValidity);
106  }
107 
108  AliDebug(1,Form("runNumber=%d ocdbPath=%s type=%s startOfValidity=%d store=%p",
109  runNumber,ocdbPath,type,startOfValidity,store));
110 
111  delete store;
112  }
113 
114  if ( fData )
115  {
116  TString shortName(fData->GetName());
117  TString cdbPath(ocdbPath);
118 
119  shortName = type;
120 
121  shortName += Form("%d",startOfValidity);
122 
123  shortName += "(";
124 
125  if ( cdbPath.Contains("cvmfs/alice") )
126  {
127  shortName += "cvmfs";
128  }
129  else if ( cdbPath.BeginsWith("alien://folder=/alice/data") )
130  {
131  shortName += "alien";
132  }
133  else if ( cdbPath.BeginsWith("alien") && cdbPath.Contains("user") )
134  {
135  shortName.ReplaceAll("/alice.cern.ch/user/","...");
136  }
137  else
138  {
139  shortName += cdbPath;
140  }
141 
142  shortName += ")";
143 
144 
145  fData->SetName(shortName);
146  }
147 
148  AliCDBManager::Instance()->SetDefaultStorage(storage);
149 }
150 
151 //_____________________________________________________________________________
154 fData(0x0),
155 fSource(Form("%s-%s",filename,type)),
156 fIsOwnerOfData(kTRUE)
157 {
159 
160  TString sFilename(gSystem->ExpandPathName(filename));
161 
162  std::ifstream in(sFilename.Data());
163  if (in.good())
164  {
165  std::ostringstream stream;
166  char line[1024];
167  while ( in.getline(line,1024) )
168  {
169  stream << line << "\n";
170  }
171 
172  in.close();
173 
174  Int_t dummy;
175 
176  AliMUONVStore* store = CreateStore(-1,stream.str().c_str(),type,dummy);
177 
178  if ( store )
179  {
180  fData = CreateData(type,*store,dummy);
181  }
182  delete store;
183  }
184 }
185 
186 //_____________________________________________________________________________
187 AliMUONTrackerConditionDataMaker::AliMUONTrackerConditionDataMaker(const char* data, const char* type, Bool_t) :
189 fData(0x0),
190 fSource(Form("direct-%s",type)),
191 fIsOwnerOfData(kTRUE)
192 
193 {
196 
197  Int_t dummy;
198 
199  AliMUONVStore* store = CreateStore(-1,data,type,dummy);
200 
201  if ( store )
202  {
203  fData = CreateData(type,*store,dummy);
204  }
205  delete store;
206 
207 }
208 
209 //_____________________________________________________________________________
211 {
213  if ( fIsOwnerOfData ) delete fData;
214 }
215 
216 
217 //_____________________________________________________________________________
219 AliMUONTrackerConditionDataMaker::CreateData(const char* type, AliMUONVStore& store, Int_t startOfValidity)
220 {
222  AliMUONVTrackerData* data(0x0);
223 
225  {
226  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForCapacitances(),startOfValidity),"Capacitances",2,kTRUE);
227  data->SetDimensionName(0,"Capa");
228  data->SetDimensionName(1,"Injection gain");
229  }
230  else if ( AliMUONTrackerDataSourceTypes::IsConfig(type ) )
231  {
232  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForConfig(),startOfValidity),"Configuration",1);
233  data->SetDimensionName(0,"there");
234  data->DisableChannelLevel();
235  }
237  {
238  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForGains(),startOfValidity),"Gains",7,kTRUE);
239  data->SetDimensionName(0,"gain");
240  data->SetDimensionName(1,"a1");
241  data->SetDimensionName(2,"a2");
242  data->SetDimensionName(3,"thres");
243  data->SetDimensionName(4,"qual1");
244  data->SetDimensionName(5,"qual2");
245  data->SetDimensionName(6,"sat");
246  }
247  else if ( AliMUONTrackerDataSourceTypes::IsHV(type) )
248  {
249  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForHV(),startOfValidity),"High Voltages",1); //,!isSingleEvent);
250  data->SetDimensionName(0,"HV");
251  }
253  {
254  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForOccupancy(),startOfValidity),"OccupancyMap",store);
255  data->SetDimensionName(0,"One");
256  return data; // important to return now to avoid the data->Add(store) later on...
257  }
259  {
260  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForPedestals(),startOfValidity),"Pedestals",2,kTRUE);
261  data->SetDimensionName(0,"Mean");
262  data->SetDimensionName(1,"Sigma");
263  }
265  {
266  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForStatus(),startOfValidity),"Status",1,kTRUE);
267  data->SetDimensionName(0,"Bits");
268  }
270  {
271  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForStatusMap(),startOfValidity),"Status map",2,kTRUE);
272  data->SetDimensionName(0,"Bits");
273  data->SetDimensionName(1,"Dead");
274  }
275 
276  if (!data)
277  {
278  AliErrorClass(Form("Could not create data for type=%s",type));
279  return 0x0;
280  }
281 
282  data->Add(store);
283 
284  return data;
285 }
286 
287 //_____________________________________________________________________________
290 {
292 
293  AliMUONVStore* store = new AliMUON2DMap(kTRUE);
294 
295  TIter next(&m);
296  TObjString* s;
297  AliMpDCSNamer hvNamer("TRACKER");
298 
299  while ( ( s = static_cast<TObjString*>(next()) ) )
300  {
301  TString name(s->String());
302 
303  Int_t hvIndex = hvNamer.DCSIndexFromDCSAlias(name.Data());
304 
305  Int_t detElemId = hvNamer.DetElemIdFromDCSAlias(name.Data());
306 
307  if ( hvIndex >= 0 && detElemId < 0 )
308  {
309  // skip switches
310  continue;
311  }
312 
313  if ( !AliMpDEManager::IsValidDetElemId(detElemId) )
314  {
315  AliErrorClass(Form("Got an invalid DE = %d from alias = %s",
316  detElemId,name.Data()));
317  continue;
318  }
319 
320  Int_t nPCBs = hvNamer.NumberOfPCBs(detElemId);
321  Int_t indexMin = nPCBs ? 0 : hvIndex;
322  Int_t indexMax = nPCBs ? nPCBs : hvIndex+1;
323 
325 
326  for ( int i = indexMin ; i < indexMax; ++i )
327  {
328  Float_t switchValue(1.0);
329 
330  if ( nPCBs )
331  {
332  TString switchName(hvNamer.DCSSwitchAliasName(detElemId,i));
333 
334  TPair* p = static_cast<TPair*>(m.FindObject(switchName.Data()));
335  TObjArray* a = static_cast<TObjArray*>(p->Value());
336 
337  switchValue = AliMUONPadStatusMaker::SwitchValue(*a);
338  }
339 
340  const AliMpArrayI* manus = de->ManusForHV(i);
341 
342  if (!manus) continue;
343 
344  TPair* p = static_cast<TPair*>(m.FindObject(name.Data()));
345  TObjArray* a = static_cast<TObjArray*>(p->Value());
346  TIter n2(a);
347  AliDCSValue* v;
348  Float_t hvValue(0);
349  Int_t n(0);
350  Int_t noff(0);
351 
352  while ( ( v = static_cast<AliDCSValue*>(n2()) ) )
353  {
354  hvValue += v->GetFloat();
355  if ( v->GetFloat() < AliMpDCSNamer::TrackerHVOFF() ) ++noff;
356  ++n;
357  }
358  hvValue *= switchValue;
359 
360  if ( n ) hvValue /= n;
361 
362  if (noff>0 && noff<n)
363  {
364  // that's a trip
365  hvValue = -1.0;
366  }
367 
368  Int_t nofChannels(AliMpConstants::ManuNofChannels());
369 
370  for ( Int_t k = 0 ; k < manus->GetSize(); ++k )
371  {
372  Int_t manuId = manus->GetValue(k);
373  AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(store->FindObject(detElemId,manuId));
374  if ( ! param )
375  {
376  param = new AliMUONCalibParamND(1,nofChannels,detElemId,manuId,0);
377  store->Add(param);
378  }
379  for ( Int_t j = 0 ; j < nofChannels; ++j )
380  {
381  param->SetValueAsDouble(j,0,hvValue);
382  }
383  }
384  }
385  }
386 
387  return store;
388 
389 }
390 
391 //_____________________________________________________________________________
394 {
396 
397  AliMUONDigitCalibrator calibrator(runNumber);
398 
399  AliMUONVStore* sm = new AliMUON2DMap(kTRUE);
400 
402  Int_t detElemId, manuId;
403 
404  while (it.Next(detElemId,manuId))
405  {
407  for ( Int_t i = 0; i < np->Size(); ++i )
408  {
409  Int_t value = calibrator.PadStatus(detElemId,manuId,i);
410  np->SetValueAsInt(i,0,value); // "raw" value of the status
411  }
412  sm->Add(np);
413  }
414 
415  return sm;
416 }
417 
418 //_____________________________________________________________________________
421 {
423 
424  AliMUONDigitCalibrator calibrator(runNumber);
425 
426  AliMUONVStore* sm = new AliMUON2DMap(kTRUE);
427 
429  Int_t detElemId, manuId;
430 
431  while (it.Next(detElemId,manuId))
432  {
434  for ( Int_t i = 0; i < np->Size(); ++i )
435  {
436  Int_t value = calibrator.StatusMap(detElemId,manuId,i);
437  Int_t channelIsDead = ( value & AliMUONPadStatusMapMaker::SelfDeadMask() );
438  np->SetValueAsInt(i,0,value); // "raw" value of the status map
439  np->SetValueAsInt(i,1,channelIsDead); // simple 0 or 1 for this channel
440  }
441  sm->Add(np);
442  }
443 
444  return sm;
445 }
446 
447 //_____________________________________________________________________________
450  const char* source,
451  const char* type,
452  Int_t& startOfValidity)
453 {
455 
456  AliMUONVStore* store(0x0);
457 
458  startOfValidity = 0;
459 
460  Bool_t ocdb = (runNumber>=0);
461 
463  {
464  if ( ocdb )
465  {
466  store = AliMUONCalibrationData::CreateCapacitances(runNumber,&startOfValidity);
467  }
468  else
469  {
470  store = new AliMUON2DMap(20000);
472  }
473  }
475  {
476  AliMUONVStore* tmp(0x0);
477  if ( ocdb )
478  {
479  tmp = AliMUONCalibrationData::CreateConfig(runNumber,&startOfValidity);
480  }
481  else
482  {
483  tmp = new AliMUON2DMap(kTRUE);
484  AliMUONTrackerIO::DecodeConfig(source,*tmp);
485  }
486  if ( tmp )
487  {
488  store = ExpandConfig(*tmp);
489  }
490  delete tmp;
491  }
493  {
494  AliMUONVStore* gains(0x0);
495  if ( ocdb )
496  {
497  gains = AliMUONCalibrationData::CreateGains(runNumber,&startOfValidity);
498  }
499  else
500  {
501  gains = new AliMUON2DMap(kTRUE);
502  TString comment;
503  AliMUONTrackerIO::DecodeGains(source,*gains,comment);
504  }
505  store = PatchGainStore(*gains);
506  delete gains;
507  }
509  {
510  if ( ocdb )
511  {
512  store = AliMUONCalibrationData::CreateOccupancyMap(runNumber,&startOfValidity);
513  if (store) store = static_cast<AliMUONVStore*>(store->Clone());
514  }
515  else
516  {
517  store = new AliMUON2DMap(kTRUE);
518  AliMUONTrackerIO::DecodeOccupancy(source,*store);
519  }
520  }
522  {
523  if ( ocdb )
524  {
525  store = AliMUONCalibrationData::CreatePedestals(runNumber,&startOfValidity);
526  }
527  else
528  {
529  store = new AliMUON2DMap(kTRUE);
530  AliMUONTrackerIO::DecodePedestals(source,*store);
531  }
532  }
533 
535  if (!store && !ocdb)
536  {
537  return 0x0;
538  }
539 
541  {
542  TMap* m = AliMUONCalibrationData::CreateHV(runNumber,&startOfValidity);
543  store = CreateHVStore(*m);
544  delete m;
545  }
547  {
548  store = CreateStatusStore(runNumber);
549  }
551  {
552  store = CreateStatusMapStore(runNumber);
553  }
554 
555  return store;
556 }
557 
558 //_____________________________________________________________________________
561 {
564 
565  AliMUONVStore* store = manuConfig.Create();
566 
567  TIter next(manuConfig.CreateIterator());
569 
570  while ( ( p = static_cast<AliMUONVCalibParam*>(next()) ) )
571  {
572  AliMUONVCalibParam* c = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),p->ID0(),p->ID1(),0.0);
573 
575 
576  for ( Int_t i = 0; i < c->Size(); ++i )
577  {
578  if ( de->IsExistingChannel(p->ID1(),i) )
579  {
580  c->SetValueAsFloat(i,0,1.0);
581  }
582  }
583 
584  store->Add(c);
585  }
586  return store;
587 }
588 
589 //_____________________________________________________________________________
590 Long64_t
592 {
594  AliError("Not implemented. Does it have sense ?");
595  return 0;
596 }
597 
598 //_____________________________________________________________________________
601 {
606 
607  AliMUONVStore* store = gains.Create();
608 
609  TIter next(gains.CreateIterator());
610  AliMUONVCalibParam* param;
611 
612  while ( ( param = static_cast<AliMUONVCalibParam*>(next()) ) )
613  {
614  AliMUONVCalibParam* nd = new AliMUONCalibParamND(param->Dimension()+2,
615  param->Size(),
616  param->ID0(),
617  param->ID1());
618  for ( Int_t i = 0; i < param->Size(); ++i )
619  {
620 
621  Int_t qual = param->ValueAsInt(i,3);
622  Int_t q1 = (qual & 0xF0) >> 4; // linear fit quality
623  Int_t q2 = qual & 0xF; // parabolic fit quality
624  Double_t gain = 0.0;
625 
626  if ( param->ValueAsFloat(i,0) > 1E-9 ) gain = 1.0/param->ValueAsFloat(i,0)/0.2;
627 
628  nd->SetValueAsDouble(i,0,gain); // gain
629  nd->SetValueAsDouble(i,1,param->ValueAsFloat(i,0)); // a1
630  nd->SetValueAsDouble(i,2,param->ValueAsFloat(i,1)); // a2
631  nd->SetValueAsInt(i,3,param->ValueAsInt(i,2)); // thres
632  nd->SetValueAsInt(i,4,q1); // qual1
633  nd->SetValueAsInt(i,5,q2); // qual2
634  nd->SetValueAsInt(i,6,param->ValueAsInt(i,4)); // sat
635  }
636  store->Add(nd);
637  }
638 
639  return store;
640 }
641 
virtual TIterator * CreateIterator() const =0
Return an iterator to loop over the whole store.
virtual void DisableChannelLevel()=0
Disable recording of information at the channel level.
Implementation of AliMUONVTrackerData.
static Bool_t IsOccupancy(const char *type)
Whether type is of Occupancy flavour.
static AliMUONVStore * PatchGainStore(const AliMUONVStore &gains)
static AliMUONVStore * CreateOccupancyMap(Int_t runNumber, Int_t *startOfValidity=0)
Create an occupancy map store (which must be deleted) from OCDB for the given run.
static AliMUONVStore * ExpandConfig(const AliMUONVStore &config)
static Float_t SwitchValue(const TObjArray &dcsArray)
Int_t GetSize() const
#define TObjArray
Implementation of AliMUONVCalibParam for tuples of floats.
virtual Int_t Size() const =0
The number of channels handled by this object.
static Float_t TrackerHVOFF()
Definition: AliMpDCSNamer.h:64
virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value)=0
Set one value, for channel i, dimension j. Consider value is a float.
static TString comment
Definition: ConfigCosmic.C:131
static Bool_t IsPedestals(const char *type)
Whether type is of Pedestals flavour.
static Int_t DecodeGains(const char *data, AliMUONVStore &gainStore, TString &comment)
Producer of some AliMUONVTrackerData.
static AliMUONVStore * CreateCapacitances(Int_t runNumber, Int_t *startOfValidity=0)
Create a capa store (which must be deleted) from OCDB for the given run.
Collection of methods usefull to DCS handling for MUON TRK and TRG.
Definition: AliMpDCSNamer.h:21
Int_t StatusMap(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
static Int_t DecodeConfig(const char *data, AliMUONVStore &confStore)
Int_t NumberOfPCBs(Int_t detElemId) const
static AliMUONVStore * CreateConfig(Int_t runNumber, Int_t *startOfValidity=0)
Create a configuration store (which must be deleted) from OCDB for the given run. ...
virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value)=0
Set one value, for channel i, dimension j. Consider value is an integer.
AliMpDetElement * GetDetElement(Int_t detElemId, Bool_t warn=true) const
The class defines the electronics properties of detection element.
static Int_t DecodeCapacitances(const char *data, AliMUONVStore &capaStore)
Bool_t Next(Int_t &detElemId, Int_t &manuId)
Class to loop over all manus of MUON Tracker.
static AliMUONVStore * CreateStatusMapStore(Int_t runNumber)
ClassImp(TPCGenInfo)
Definition: AliTPCCmpNG.C:254
static AliMUONVStore * CreateGains(Int_t runNumber, Int_t *startOfValidity=0)
Create a gain store (which must be deleted) from OCDB for the given run.
static Bool_t IsConfig(const char *type)
Whether type is of Configuration flavour.
Container of calibration values for a given number of channels.
static AliMpDDLStore * Instance(Bool_t warn=true)
static Int_t ManuNofChannels()
Max number of channels per manu.
virtual AliMUONVStore * Create() const =0
Create an empty copy of this.
Implementation of AliMUONVCalibParam for tuples of ints.
static Bool_t IsStatusMap(const char *type)
Whether type is of StatusMap flavour.
Class to calibrate the digits.
virtual Long64_t Merge(TCollection *li)
Merge.
Implementation of AliMUONVCalibParam for tuples of double.
virtual void SetDimensionName(Int_t index, const char *value)=0
Set the name of a given dimension.
Int_t DCSIndexFromDCSAlias(const char *dcsAlias) const
Helper class for sorted integer array.
Definition: AliMpArrayI.h:21
static Int_t SelfDeadMask()
Return status bit map to tell a pad is bad.
static Bool_t IsCapacitances(const char *type)
Whether type is of Capacitance flavour.
Int_t PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
Basic implementation of AliMUONVStore container using AliMpExMap internally.
Definition: AliMUON2DMap.h:20
virtual Bool_t Add(TObject *object)=0
Add an object to the store.
static Bool_t IsGains(const char *type)
Whether type is of Gains flavour.
static AliMUONVTrackerData * CreateData(const char *type, AliMUONVStore &source, Int_t startOfValidity)
static Int_t DecodePedestals(const char *data, AliMUONVStore &pedStore)
virtual Bool_t Add(const AliMUONVStore &store, TArrayI *arrayOfNofEventsPerDDL=0x0)=0
Add values for one event from one full store.
static Bool_t IsRejectList(const char *type)
Whether type is of RejectList flavour.
static Bool_t IsStatus(const char *type)
Whether type is of Status flavour.
Object to hold the list of elements we want to reject from the reconstruction.
static Int_t DecodeOccupancy(const char *data, AliMUONVStore &occupancyMap)
TString DCSSwitchAliasName(Int_t detElemId, Int_t pcbNumber) const
static TMap * CreateHV(Int_t runNumber, Int_t *startOfValidity=0, Bool_t patched=kTRUE, TList *messages=0x0, Bool_t dryRun=kFALSE)
Create a hv map (which must be deleted) from OCDB for the given run.
const AliMpArrayI * ManusForHV(Int_t hvIndex) const
Int_t GetValue(Int_t index) const
static AliMUONVStore * CreateStatusStore(Int_t runNumber)
virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const
Int_t DetElemIdFromDCSAlias(const char *dcsAlias) const
Base class for MUON data stores.
Definition: AliMUONVStore.h:22
Bool_t IsExistingChannel(Int_t manuId, Int_t manuChannel) const
Base class for MUON data that can be presented at different levels in the hierarchy of the MUON syste...
static Bool_t IsValidDetElemId(Int_t detElemId, Bool_t warn=false)
static Bool_t IsHV(const char *type)
Whether type is of HV flavour.
static AliMUONRejectList * CreateRejectList(Int_t runNumber, Int_t *startOfValidity=0)
Create a rejectlist store (which must be deleted) from OCDB for the given run.
static AliMUONVStore * CreatePedestals(Int_t runNumber, Int_t *startOfValidity=0)
Create a pedestal store (which must be deleted) from OCDB for the given run.
virtual TObject * FindObject(const char *name) const
Find an object by name.
static AliMUONVStore * CreateStore(Int_t runNumber, const char *source, const char *type, Int_t &startOfValidity)
virtual void SetValueAsDouble(Int_t i, Int_t j, Double_t value)
Producer of AliMUONVTrackerData from OCDB or ASCII condition files.