AliRoot Core  edcc906 (edcc906)
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 //_____________________________________________________________________________
74 fData(0x0),
75 fSource(Form("%s-%010d-%s",ocdbPath,runNumber,type)),
76 fIsOwnerOfData(kTRUE)
77 {
79 
81 
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") && cdbPath.Contains("/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 
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::ShortNameForConfig(),startOfValidity),"Configuration",1);
227  data->SetDimensionName(0,"there");
228  data->DisableChannelLevel();
229  }
230  else if ( AliMUONTrackerDataSourceTypes::IsHV(type) )
231  {
232  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForHV(),startOfValidity),"High Voltages",1); //,!isSingleEvent);
233  data->SetDimensionName(0,"HV");
234  }
235  else if ( AliMUONTrackerDataSourceTypes::IsLV(type) )
236  {
237  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForLV(),startOfValidity),"Low Voltages",3); //,!isSingleEvent);
238  data->SetDimensionName(0,"ann"); // analog negative
239  data->SetDimensionName(1,"dig"); // digital
240  data->SetDimensionName(2,"anp"); // analog positive
241  }
243  {
244  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForOccupancy(),startOfValidity),"OccupancyMap",store);
245  data->SetDimensionName(0,"One");
246  return data; // important to return now to avoid the data->Add(store) later on...
247  }
249  {
250  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForPedestals(),startOfValidity),"Pedestals",2,kTRUE);
251  data->SetDimensionName(0,"Mean");
252  data->SetDimensionName(1,"Sigma");
253  }
255  {
256  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForStatus(),startOfValidity),"Status",1,kTRUE);
257  data->SetDimensionName(0,"Bits");
258  }
260  {
261  data = new AliMUONTrackerData(Form("%s%d",AliMUONTrackerDataSourceTypes::ShortNameForStatusMap(),startOfValidity),"Status map",2,kTRUE);
262  data->SetDimensionName(0,"Bits");
263  data->SetDimensionName(1,"Dead");
264  }
265 
266  if (!data)
267  {
268  AliErrorClass(Form("Could not create data for type=%s",type));
269  return 0x0;
270  }
271 
272  data->Add(store);
273 
274  return data;
275 }
276 
277 //_____________________________________________________________________________
280 {
282 
283  AliMUONVStore* store = new AliMUON2DMap(kTRUE);
284 
285  TIter next(&m);
286  TObjString* s;
287  AliMpDCSNamer hvNamer("TRACKER");
288 
289  while ( ( s = static_cast<TObjString*>(next()) ) )
290  {
291  TString name(s->String());
292 
293  Int_t hvIndex = hvNamer.DCSIndexFromDCSAlias(name.Data());
294 
295  Int_t detElemId = hvNamer.DetElemIdFromDCSAlias(name.Data());
296 
297  if ( hvIndex >= 0 && detElemId < 0 )
298  {
299  // skip switches
300  continue;
301  }
302 
303  if ( !AliMpDEManager::IsValidDetElemId(detElemId) )
304  {
305  AliErrorClass(Form("Got an invalid DE = %d from alias = %s",
306  detElemId,name.Data()));
307  continue;
308  }
309 
310  Int_t nPCBs = hvNamer.NumberOfPCBs(detElemId);
311  Int_t indexMin = nPCBs ? 0 : hvIndex;
312  Int_t indexMax = nPCBs ? nPCBs : hvIndex+1;
313 
315 
316  for ( int i = indexMin ; i < indexMax; ++i )
317  {
318  Float_t switchValue(1.0);
319 
320  if ( nPCBs )
321  {
322  TString switchName(hvNamer.DCSSwitchAliasName(detElemId,i));
323 
324  TPair* p = static_cast<TPair*>(m.FindObject(switchName.Data()));
325  TObjArray* a = static_cast<TObjArray*>(p->Value());
326 
327  switchValue = AliMUONPadStatusMaker::SwitchValue(*a);
328  }
329 
330  const AliMpArrayI* manus = de->ManusForHV(i);
331 
332  if (!manus) continue;
333 
334  TPair* p = static_cast<TPair*>(m.FindObject(name.Data()));
335  TObjArray* a = static_cast<TObjArray*>(p->Value());
336  TIter n2(a);
337  AliDCSValue* v;
338  Float_t hvValue(0);
339  Int_t n(0);
340  Int_t noff(0);
341 
342  while ( ( v = static_cast<AliDCSValue*>(n2()) ) )
343  {
344  hvValue += v->GetFloat();
345  if ( v->GetFloat() < AliMpDCSNamer::TrackerHVOFF() ) ++noff;
346  ++n;
347  }
348  hvValue *= switchValue;
349 
350  if ( n ) hvValue /= n;
351 
352  if (noff>0 && noff<n)
353  {
354  // that's a trip
355  hvValue = -1.0;
356  }
357 
358  Int_t nofChannels(AliMpConstants::ManuNofChannels());
359 
360  for ( Int_t k = 0 ; k < manus->GetSize(); ++k )
361  {
362  Int_t manuId = manus->GetValue(k);
363  AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(store->FindObject(detElemId,manuId));
364  if ( ! param )
365  {
366  param = new AliMUONCalibParamND(1,nofChannels,detElemId,manuId,0);
367  store->Add(param);
368  }
369  for ( Int_t j = 0 ; j < nofChannels; ++j )
370  {
371  param->SetValueAsDouble(j,0,hvValue);
372  }
373  }
374  }
375  }
376 
377  return store;
378 
379 }
380 
381 //_____________________________________________________________________________
384 {
386 
387  AliMUONVStore* store = new AliMUON2DMap(kTRUE);
388 
389  TIter next(&m);
390  TObjString* s;
391  AliMpDCSNamer hvNamer("TRACKER");
392 
393  while ( ( s = static_cast<TObjString*>(next()) ) )
394  {
395  TString name(s->String());
396 
397  Int_t index(0);
398 
399  if ( name.Contains("ann") ) index = 0;
400  if ( name.Contains("dig") ) index = 1;
401  if ( name.Contains("anp") ) index = 2;
402 
403  Int_t* detElemId(0x0);
404  Int_t numberOfDetectionElements;
405  AliMp::PlaneType planeType;
406 
407  hvNamer.DecodeDCSMCHLVAlias(name.Data(), detElemId, numberOfDetectionElements, planeType);
408 
409  if (planeType != AliMp::kBendingPlane)
410  {
411  std::cout << "cool " << detElemId[0] << std::endl;
412  }
413  // compute the value to be associated with that alias : either the mean
414  // or zero if a trip is detected
415  Float_t lvValue(0.0);
416 
417  TPair* p = static_cast<TPair*>(m.FindObject(name.Data()));
418  TObjArray* a = static_cast<TObjArray*>(p->Value());
419  TIter n2(a);
420  AliDCSValue* v;
421  Int_t n(0);
422  Int_t noff(0);
423 
424  while ( ( v = static_cast<AliDCSValue*>(n2()) ) )
425  {
426  lvValue += v->GetFloat();
427  if ( v->GetFloat() < AliMpDCSNamer::TrackerLVOFF() ) ++noff;
428  ++n;
429  }
430 
431  if ( n ) lvValue /= n;
432 
433  if (noff>0 && noff<n)
434  {
435  // that's a trip
436  lvValue = -1.0;
437  }
438 
439  Int_t nofChannels(AliMpConstants::ManuNofChannels());
440 
441  // now assign this LV value to all the manus of the relevant plane(s)
442  // of the detection element(s)
443 
444  for ( int i = 0; i < numberOfDetectionElements; ++i )
445  {
446  AliMpManuIterator manuIterator;
447  Int_t de, manuId;
448 
449  //std::cout << Form("DE %04d planeType %d value %g",detElemId[i],planeType,lvValue) << std::endl;
450 
451  while (manuIterator.Next(de,manuId))
452  {
453  if ( de != detElemId[i] ) continue;
454  if ( de < 500 )
455  {
456  if ( planeType == AliMp::kNonBendingPlane &&
457  ( ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) ) == 0 ) ) continue;
458  if ( planeType == AliMp::kBendingPlane &&
459  ( ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) ) != 0 ) ) continue;
460  }
461  AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(store->FindObject(de,manuId));
462  if ( ! param )
463  {
464  param = new AliMUONCalibParamND(3,nofChannels,de,manuId,0);
465  store->Add(param);
466  }
467  for ( Int_t j = 0 ; j < nofChannels; ++j )
468  {
469  param->SetValueAsDouble(j,index,lvValue);
470  }
471  }
472 
473  }
474  delete[] detElemId;
475  }
476 
477  return store;
478 }
479 
480 //_____________________________________________________________________________
483 {
485 
486  AliMUONDigitCalibrator calibrator(runNumber);
487 
488  AliMUONVStore* sm = new AliMUON2DMap(kTRUE);
489 
491  Int_t detElemId, manuId;
492 
493  while (it.Next(detElemId,manuId))
494  {
496  for ( Int_t i = 0; i < np->Size(); ++i )
497  {
498  Int_t value = calibrator.PadStatus(detElemId,manuId,i);
499  np->SetValueAsInt(i,0,value); // "raw" value of the status
500  }
501  sm->Add(np);
502  }
503 
504  return sm;
505 }
506 
507 //_____________________________________________________________________________
510 {
512 
513  AliMUONDigitCalibrator calibrator(runNumber);
514 
515  AliMUONVStore* sm = new AliMUON2DMap(kTRUE);
516 
518  Int_t detElemId, manuId;
519 
520  while (it.Next(detElemId,manuId))
521  {
523  for ( Int_t i = 0; i < np->Size(); ++i )
524  {
525  Int_t value = calibrator.StatusMap(detElemId,manuId,i);
526  Int_t channelIsDead = ( value & AliMUONPadStatusMapMaker::SelfDeadMask() );
527  np->SetValueAsInt(i,0,value); // "raw" value of the status map
528  np->SetValueAsInt(i,1,channelIsDead); // simple 0 or 1 for this channel
529  }
530  sm->Add(np);
531  }
532 
533  return sm;
534 }
535 
536 //_____________________________________________________________________________
539  const char* source,
540  const char* type,
541  Int_t& startOfValidity)
542 {
544 
545  AliMUONVStore* store(0x0);
546 
547  startOfValidity = 0;
548 
549  Bool_t ocdb = (runNumber>=0);
550 
552  {
553  AliMUONVStore* tmp(0x0);
554  if ( ocdb )
555  {
556  tmp = AliMUONCalibrationData::CreateConfig(runNumber,&startOfValidity);
557  }
558  else
559  {
560  tmp = new AliMUON2DMap(kTRUE);
561  AliMUONTrackerIO::DecodeConfig(source,*tmp);
562  }
563  if ( tmp )
564  {
565  store = ExpandConfig(*tmp);
566  }
567  delete tmp;
568  }
570  {
571  if ( ocdb )
572  {
573  store = AliMUONCalibrationData::CreateOccupancyMap(runNumber,&startOfValidity);
574  if (store) store = static_cast<AliMUONVStore*>(store->Clone());
575  }
576  else
577  {
578  store = new AliMUON2DMap(kTRUE);
579  AliMUONTrackerIO::DecodeOccupancy(source,*store);
580  }
581  }
583  {
584  if ( ocdb )
585  {
586  store = AliMUONCalibrationData::CreatePedestals(runNumber,&startOfValidity);
587  }
588  else
589  {
590  store = new AliMUON2DMap(kTRUE);
591  AliMUONTrackerIO::DecodePedestals(source,*store);
592  }
593  }
594 
596  if (!store && !ocdb)
597  {
598  return 0x0;
599  }
600 
602  {
603  TMap* m = AliMUONCalibrationData::CreateHV(runNumber,&startOfValidity);
604  store = CreateHVStore(*m);
605  delete m;
606  }
608  {
609  TMap* m = AliMUONCalibrationData::CreateLV(runNumber,&startOfValidity);
610  store = CreateLVStore(*m);
611  delete m;
612  }
614  {
615  store = CreateStatusStore(runNumber);
616  }
618  {
619  store = CreateStatusMapStore(runNumber);
620  }
621 
622  return store;
623 }
624 
625 //_____________________________________________________________________________
628 {
631 
632  AliMUONVStore* store = manuConfig.Create();
633 
634  TIter next(manuConfig.CreateIterator());
636 
637  while ( ( p = static_cast<AliMUONVCalibParam*>(next()) ) )
638  {
639  AliMUONVCalibParam* c = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),p->ID0(),p->ID1(),0.0);
640 
642 
643  for ( Int_t i = 0; i < c->Size(); ++i )
644  {
645  if ( de->IsExistingChannel(p->ID1(),i) )
646  {
647  c->SetValueAsFloat(i,0,1.0);
648  }
649  }
650 
651  store->Add(c);
652  }
653  return store;
654 }
655 
656 //_____________________________________________________________________________
657 Long64_t
659 {
661  AliError("Not implemented. Does it have sense ?");
662  return 0;
663 }
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 * 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:75
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 Bool_t IsPedestals(const char *type)
Whether type is of Pedestals flavour.
Producer of some AliMUONVTrackerData.
Collection of methods usefull to DCS handling for MUON TRK and TRG.
Definition: AliMpDCSNamer.h:22
Float_t p[]
Definition: kNNTest.C:133
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.
Float_t GetFloat() const
static Float_t TrackerLVOFF()
Definition: AliMpDCSNamer.h:78
Bool_t Next(Int_t &detElemId, Int_t &manuId)
Class to loop over all manus of MUON Tracker.
static AliMUONVStore * CreateStatusMapStore(Int_t runNumber)
static Bool_t IsConfig(const char *type)
Whether type is of Configuration flavour.
Container of calibration values for a given number of channels.
#define AliErrorClass(message)
Definition: AliLog.h:596
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.
Bool_t DecodeDCSMCHLVAlias(const char *dcsAlias, Int_t *&detElemId, Int_t &numberOfDetectionElements, AliMp::PlaneType &planeType) const
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.
non-bending plane
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.
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
void SetDefaultStorage(const char *dbString)
bending plane
virtual Bool_t Add(TObject *object)=0
Add an object to the store.
#define AliDebug(logLevel, message)
Definition: AliLog.h:300
static AliMUONVTrackerData * CreateData(const char *type, AliMUONVStore &source, Int_t startOfValidity)
static Int_t DecodePedestals(const char *data, AliMUONVStore &pedStore)
static TMap * CreateLV(Int_t runNumber, Int_t *startOfValidity=0)
Create a MCH LV map (which must be deleted) from OCDB for the given run.
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.
AliCDBStorage * GetDefaultStorage() const
Definition: AliCDBManager.h:61
static Int_t DecodeOccupancy(const char *data, AliMUONVStore &occupancyMap)
TString DCSSwitchAliasName(Int_t detElemId, Int_t pcbNumber) const
static Int_t runNumber
Definition: pdc06_config.C:126
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
#define AliError(message)
Definition: AliLog.h:591
Int_t GetValue(Int_t index) const
static AliMUONVStore * CreateStatusStore(Int_t runNumber)
static AliCDBManager * Instance(TMap *entryCache=NULL, Int_t run=-1)
static Bool_t IsLV(const char *type)
Whether type is of LV flavour.
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)
static Int_t ManuMask(AliMp::PlaneType planeType)
virtual void SetValueAsDouble(Int_t i, Int_t j, Double_t value)
Producer of AliMUONVTrackerData from OCDB or ASCII condition files.