ROOT logo
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

// $Id: AliMUONCalibrationData.cxx 59486 2012-11-07 22:06:24Z laphecet $

#include "AliMUONCalibrationData.h"

#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCodeTimer.h"
#include "AliDCSValue.h"
#include "AliLog.h"
#include "AliMpDCSNamer.h"
#include "AliMpIntPair.h"
#include "AliMUONGlobalCrateConfig.h"
#include "AliMUONRegionalTriggerConfig.h"
#include "AliMUONRejectList.h"
#include "AliMUONTriggerEfficiencyCells.h"
#include "AliMUONTriggerLut.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVStore.h"
#include "AliMUONVStore.h"

#include <Riostream.h>
#include <TClass.h>
#include <TMap.h>
#include <TMath.h>

//-----------------------------------------------------------------------------
/// \class AliMUONCalibrationData
///
/// For the moment, this class stores pedestals, gains, hv (for tracker)
/// and lut, masks and efficiencies (for trigger) that are fetched from the CDB.
///
/// This class is to be considered as a convenience class.
/// Its aim is to ease retrieval of calibration data from the 
/// condition database.
///
/// It acts as a "facade" to a bunch of underlying 
/// containers/calibration classes.
///
/// \author Laurent Aphecetche
//-----------------------------------------------------------------------------

using std::cout;
using std::endl;
/// \cond CLASSIMP
ClassImp(AliMUONCalibrationData)
/// \endcond

AliMUONVStore* AliMUONCalibrationData::fgBypassPedestals(0x0);
AliMUONVStore* AliMUONCalibrationData::fgBypassGains(0x0);

UInt_t AliMUONCalibrationData::fgkDCSSt1Flag(42);

namespace
{
  void MarkForDeletion(Int_t* indices, Int_t first, Int_t last)
  {
    for ( Int_t i = first; i <= last; ++i ) 
    {
      indices[i] = 1;
    }
  }
}

//_____________________________________________________________________________
AliMUONCalibrationData::AliMUONCalibrationData(Int_t runNumber, 
                                               Bool_t deferredInitialization) 
: TObject(), 
fIsValid(kTRUE),
fRunNumber(runNumber), 
fGains(0x0), 
fPedestals(0x0),
fHV(0x0),
fTriggerDCS(0x0),
fLocalTriggerBoardMasks(0x0),
fRegionalTriggerConfig(0x0),
fGlobalTriggerCrateConfig(0x0),
fTriggerLut(0x0),
fTriggerEfficiency(0x0),
fCapacitances(0x0),
fNeighbours(0x0),
fOccupancyMap(0x0),
fRejectList(0x0),
fConfig(0x0)
{
/// Default ctor.

  // If deferredInitialization is false, we read *all* calibrations
  // at once.
  // So when using this class to access only one kind of calibrations (e.g.
  // only pedestals), you should put deferredInitialization to kTRUE, which
  // will instruct this object to fetch the data only when neeeded.

  if ( deferredInitialization == kFALSE )
  {
    Gains();
    Pedestals();
    OccupancyMap();
    RejectList();
    HV();
    TriggerDCS();
    LocalTriggerBoardMasks(0);
    RegionalTriggerConfig();
    GlobalTriggerCrateConfig();
    TriggerLut();
    TriggerEfficiency();
    Capacitances();
    Neighbours();
    Config();
  }
}

//_____________________________________________________________________________
AliMUONCalibrationData::~AliMUONCalibrationData()
{
  /// Destructor. Note that we're the owner of our pointers if the OCDB cache
  /// is not set. Otherwise the cache is supposed to take care of them...
  if (!(AliCDBManager::Instance()->GetCacheFlag())) Reset();
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::Capacitances() const
{
  /// Create (if needed) and return the internal store for capacitances.
  
  if (!fCapacitances)
  {
    fCapacitances = CreateCapacitances(fRunNumber);
  }
  return fCapacitances;
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreateCapacitances(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create capa store from OCDB for a given run
  
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Capacitances",startOfValidity));
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreateGains(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a new gain store from the OCDB for a given run
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Gains",startOfValidity));
}

//_____________________________________________________________________________
AliMUONGlobalCrateConfig*
AliMUONCalibrationData::CreateGlobalTriggerCrateConfig(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create the internal store for GlobalTriggerCrateConfig from OCDB
  
  return dynamic_cast<AliMUONGlobalCrateConfig*>(CreateObject(runNumber,"MUON/Calib/GlobalTriggerCrateConfig",startOfValidity));
}


//______________________________________________________________________________
Bool_t AliMUONCalibrationData::CheckHVGroup(TObjArray& values, Int_t first, Int_t last, Double_t& value, Int_t& slope, TString* msg)
{
  // Get the HV of the values between first and last indices
  // return the HV slope  (in Volt per second) and a message
  // Return kFALSE if we must discard the group
  //
  
  if (msg) *msg="";
  
  if ( last < first ) return kFALSE;
  if ( last - first < 2 ) return kFALSE;
  
  Double_t a(0.0);
  Double_t b(0.0);

  Float_t HVSAME(1); // 1 volts

  AliDCSValue* vfirst = static_cast<AliDCSValue*>(values.UncheckedAt(first));
  AliDCSValue* vlast = static_cast<AliDCSValue*>(values.UncheckedAt(last));

  Int_t deltaHV = TMath::Nint(TMath::Abs(vfirst->GetFloat()-vlast->GetFloat()));
  
  if ( deltaHV < HVSAME ) return kFALSE;

  for ( Int_t i = first; i <= last; ++i )
  {
    AliDCSValue* v = static_cast<AliDCSValue*>(values.UncheckedAt(i));

    Double_t y = v->GetFloat() - vfirst->GetFloat();
    Double_t x = v->GetTimeStamp() - vfirst->GetTimeStamp();
  
    a += x*y;
    b += x*x;
  }
  
  value = a/b;
  slope = value > 0 ? 1 : -1;
  value = TMath::Abs(value);
  
  UInt_t deltaTime = vlast->GetTimeStamp() - vfirst->GetTimeStamp();
  
  if (msg)
  {
    if (slope>0) (*msg) = Form("RU%d[%d:%d](%d)",TMath::Nint(value),first,last,deltaTime);
    if (slope<0) (*msg) = Form("RD%d[%d:%d](%d)",TMath::Nint(value),first,last,deltaTime);
    
    if ( TMath::Nint(value) == 0 )
    {
      // this is to protect for the few cases 
      // (see e.g. MchHvLvLeft/Chamber00Left/Quad2Sect0.actual.vMon in run 134497)
      // where we can have *lots* of values (2483 in this example) but that
      // are more or less constant...
      //
      // or simply to remove small ramps
      //
      slope = 0;
      value = (vfirst->GetFloat()+vlast->GetFloat())/2.0;
      *msg = Form("FLUCT%d[%d:%d]",TMath::Nint(value),first,last);
    }
  }
  
  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliMUONCalibrationData::PatchHVValues(TObjArray& values,
                                             TString* msg,
                                             Bool_t dryRun)
{
  /// We do here a little bit of massaging of the HV values, if needed.
  ///
  /// The main point is to "gather" values that are within a given small amount
  /// of time (typically 60 seconds) and infer a slope from those values
  /// slope > 0 means it is a ramp-up, slope < 0 that's a ramp-down
  ///
  /// This is to avoid both the "ramp-down-before-end-of-run" and the
  /// "ramp-up-after-start-of-run" syndroms...
  ///
  /// Use dryRun = kTRUE to fill the messages *without* altering the values
  ///
  /// Return kFALSE is the kind of HV (trouble) case we have here
  /// has not been identified...
  ///
  
  UInt_t DELTATIME(60); // in seconds
  Int_t IENDRU(60); // in seconds
  
  // Start by finding groups of values which are not separated (each) by more than
  // deltaTime
  
  Bool_t gather(kFALSE);
  Int_t ifirst(0);
  Int_t ilast(0);
  TObjArray groups;
  groups.SetOwner(kTRUE);
  
  for ( Int_t i = values.GetLast(); i > 0; --i ) 
  {
    AliDCSValue* vi = static_cast<AliDCSValue*>(values.UncheckedAt(i));
    AliDCSValue* vj = static_cast<AliDCSValue*>(values.UncheckedAt(i-1));

    if ( vi->GetTimeStamp() - vj->GetTimeStamp() < DELTATIME )
    {
      if ( !gather ) 
      {
        gather = kTRUE;
        ifirst = i;    
      }
      ilast=i;
    }
    else
    {
      if ( gather ) 
      {
        ilast=i;
        
        groups.Add(new AliMpIntPair(ilast,ifirst));
      }
      gather = kFALSE;
    }
  }
  
  if (gather)
  {
    groups.Add(new AliMpIntPair(0,ifirst));
  }
                 
  TIter nextGroup(&groups,kIterBackward);
  AliMpIntPair* p;
  TString internalMsg;
  Int_t ngroups(0);

  Int_t nRU(0);
  Int_t nRD(0);
  Int_t nStartRU(0);
  Int_t nEndAndShortRU(0);
  Int_t nEndRD(0);
  Int_t nTripRD(0);
  Int_t nFluct(0);
  TObjArray trips;
  trips.SetOwner(kTRUE);
  
  while ( ( p = static_cast<AliMpIntPair*>(nextGroup()) ) )
  {
    Double_t value;
    Int_t slope;
    
    TString groupMsg;
    
    AliDebugClass(1,Form("group %d:%d",p->GetFirst(),p->GetSecond()));
    
    Bool_t ok = CheckHVGroup(values,p->GetFirst(),p->GetSecond(),value,slope,&groupMsg);
    
    if (!ok) continue;
    
    ++ngroups;
    
    if ( slope > 0 )
    {
      if ( p->GetFirst() == 0 ) 
      {
        // start with a ramp-up
        ++nStartRU;
      }
      else if ( p->GetSecond() == values.GetLast() && TMath::Nint(value) < IENDRU )
      {
        ++nEndAndShortRU;
      }
      else
      {
        // ramp-up in the middle of nowhere...
        ++nRU;
      }
    }
    else if ( slope < 0 )
    {
      if ( p->GetSecond() == values.GetLast() ) 
      {
        // end with a ramp-down
        ++nEndRD;
      }
      else
      {
        // ramp-down in the middle of nowhere
        ++nRD;
      }

      AliDCSValue* d = static_cast<AliDCSValue*>(values.At(p->GetSecond()));
      
      if ( d->GetFloat() < AliMpDCSNamer::TrackerHVOFF() )
      {
        ++nTripRD;
        AliDCSValue* tripStart = static_cast<AliDCSValue*>(values.At(p->GetFirst()));        
        trips.Add(new AliMpIntPair(tripStart->GetTimeStamp(),TMath::Nint(tripStart->GetFloat())));
      }
    }
    else
    {
      ++nFluct;
    }
    
    internalMsg += groupMsg;
    internalMsg += " ";    
  }
  
  /*
   
   Once we have "decoded" the groups we try to find out which of 
   the following cases we're facing :
  
   case A = -------- = OK(1)
  
   case B = ----
                \
                \   = OK, once we have removed the ramp-down (2)
  
   case C =    ----- 
              /
             /       = OK, once we have removed the ramp-up (3)
  
   case D =    ----- 
              /     \
             /       \ = OK, once we have removed the ramp-down (2) and the ramp-up (3)
  
   case E = ----
                \
                 \____ = TRIP = BAD (here the ramp-down slope should be bigger than in case C)
  
   case F = ----         
                \      ----- = BAD (trip + ramp-up at end of run)
                 \____/   
  
   case G = fluctuations (within a range defined in CheckHVGroup...)
   
   case H =            
                   /
                  /   = ramp-up right at the end-of-run = OK (4)
            ------
   
   (1) OK means the group is identified correctly, still the value can be below ready...
   (2) ramp-down values will be removed if the ramp is indeed the last values in the serie
       i.e. it's really an end-of-run problem (otherwise it's not case B)
   (3) ramp-up values will be removed if the ramp is indeed the first values in the serie
       i.e. it's really a start-of-run problem (otherwise it's not case C)
   (4) OK if short enough...
   
   Any other case is unknown and we'll :
   a) return kFALSE
   b) assume the channel is OFF.
  
  
  */
  
  AliDebugClass(1,Form("msg=%s ngroupds=%d",internalMsg.Data(),ngroups));
  AliDebugClass(1,Form("nRU %d nRD %d nStartRU %d nEndRD %d nTripRD %d nFluct %d",
                       nRU,nRD,nStartRU,nEndRD,nTripRD,nFluct));
  
  TString hvCase("OTHER");
  int dummy(0),a(-1),b(-1);
  char r[81];
  Int_t nvalues = values.GetSize();  
  Int_t* indices = new Int_t[nvalues];
  memset(indices,0,nvalues*sizeof(Int_t));
         
  AliDCSValue* vfirst = static_cast<AliDCSValue*>(values.UncheckedAt(0));
  AliDCSValue* vlast = static_cast<AliDCSValue*>(values.UncheckedAt(values.GetLast()));

  UInt_t meanTimeStamp = ( vfirst->GetTimeStamp() + vlast->GetTimeStamp() ) / 2;
  
  if ( ngroups == 0 ) 
  {
    hvCase = "A"; 
  }
  else if ( nTripRD > 0 )
  {
    const Double_t HVLOWTRIP(600); // a trip below this value is considered a "low trip"
    // i.e. one starting for a non-operational voltage
    
    internalMsg += Form("NT:%d ",nTripRD);
    
    if ( nRU > 0 && nRD > 0 )
    {
      hvCase = "F";
    }
    else
    {
      hvCase = "E";
    }
    
    for ( Int_t iTrip = 0; iTrip <= trips.GetLast(); ++iTrip )
    {
      AliMpIntPair* tripPair = static_cast<AliMpIntPair*>(trips.At(iTrip));
      TString tripType("TRIP");
      if ( tripPair->GetSecond() < HVLOWTRIP)
      {
        tripType = "LOWTRIP";
      }

      internalMsg += Form("%s SV:%d TS:%d ",tripType.Data(),tripPair->GetSecond(),tripPair->GetFirst());
    }
    
    // we put here the TRIP value as SV:value
    // for cases where there's a drop in voltage but the starting point was
    // below operational voltage, so strictly speaking it's *not* a trip, but
    // more a big fluctuation
    if ( !dryRun )
    {
      MarkForDeletion(indices,0,values.GetLast());
      values.Add(new AliDCSValue(static_cast<Float_t>(0),meanTimeStamp));
    }
  }
  else if ( nStartRU > 0 && nRU == 0 && nRD == 0 && nEndRD == 0 )
  {
    hvCase = "C";
    if (!dryRun)
    {
      sscanf(internalMsg.Data(),"RU%10d[%10d:%10d]%80s",&dummy,&a,&b,r);
      MarkForDeletion(indices,a,b);
    }
  }
  else if ( nStartRU > 0 && nEndRD > 0 && nRD == 0 && nRU == 0 )
  {
    hvCase = "D";
    if (!dryRun)
    {
      sscanf(internalMsg.Data(),"RU%10d[%10d:%10d]%80s",&dummy,&a,&b,r);
      MarkForDeletion(indices,a,b-1);
      Int_t i = internalMsg.Index("RD",strlen("RD"),0,TString::kExact);
      sscanf(internalMsg(i,internalMsg.Length()-i).Data(),
             "RD%10d[%10d:%10d]%80s",&dummy,&a,&b,r);
      MarkForDeletion(indices,a+1,b);
    }
  }
  else if ( nEndRD > 0 && nStartRU == 0 && nRU == 0 && nRD == 0 )
  {
    hvCase = "B";
    if  (!dryRun)
    {
      Int_t i = internalMsg.Index("RD",strlen("RD"),0,TString::kExact);
      sscanf(internalMsg(i,internalMsg.Length()-i).Data(),
             "RD%10d[%10d:%10d]%80s",&dummy,&a,&b,r);
      MarkForDeletion(indices,a,b);
    }
  }
  else if ( nFluct > 0 )
  {
    hvCase = "G";
    if (!dryRun)
    {
      TObjArray* af = internalMsg.Tokenize(" ");
      TIter next(af);
      TObjString* str;
      while ( ( str = static_cast<TObjString*>(next()) ) )
      {
        TString s(str->String());
        if ( s.BeginsWith("FLUCT") )
        {
          sscanf(s.Data(),"FLUCT%d[%d:%d]",&dummy,&a,&b);
          MarkForDeletion(indices,a,b);
        }
      }
      delete af;
    }
  }
  else if ( nEndAndShortRU > 0 && nStartRU == 0 && nRU == 0 && nRD == 0 && nEndRD == 0 )
  {
    hvCase = "H";
    if (!dryRun)
    {
      sscanf(internalMsg.Data(),"RU%10d[%10d:%10d]%80s",&dummy,&a,&b,r);
      MarkForDeletion(indices,a,b);
    }
  }
  else
  {
    // last chance... 
    // here we know it's not a trip, so let's assume everything is OK
    // if first and last value are in the same ballpark

    const Double_t HVFLUCT(20); // volts
    
    if ( TMath::Abs(vfirst->GetFloat() - vlast->GetFloat()) < HVFLUCT )
    {
      hvCase = "Z";
    }
    if (!dryRun)
    {
      MarkForDeletion(indices,1,nvalues-1);
    }
  }
  
  if (!dryRun)
  {
    for ( Int_t i = 0; i < nvalues; ++i )
    {
      if ( indices[i] )
      {
        values.RemoveAt(i);
      }
    }
  
    values.Compress();
  }
  
  delete[] indices;
  
  if ( !values.GetEntries() )
  {
    AliErrorClass(Form("No value left after patch... Check that !!! initial # of values=%d msg=%s",
                       nvalues,internalMsg.Data()));
    hvCase = "OTHER";
  }

  if (!dryRun)
  {
    // take the max of the remaining values
    TIter nextA(&values);
    AliDCSValue* val;
    Float_t maxval(-9999);
  
    while ( ( val = static_cast<AliDCSValue*>(nextA()) ) )
    {
      if ( val->GetFloat() > maxval )
      {
        maxval = val->GetFloat();
      }
    }
  
    values.Clear();
  
    values.Add(new AliDCSValue(maxval,meanTimeStamp));
  }
  
  // once the case is inferred, add a "CASE:%10d",hvCase.Data()
  // to the msg
  // so we can them sum up for all channels and get a summary per run...
  
  internalMsg += Form("CASE:%s",hvCase.Data());
 
  if (msg) *msg = internalMsg.Data();
  
  return hvCase=="OTHER" ? kFALSE : kTRUE;
}

//_____________________________________________________________________________
void AliMUONCalibrationData::AddToMap(const TMap& sourceMap,
                                      TMap& destMap,
                                      const TString& key,
                                      const char* source,
                                      const char* dest)
{
  /// Remap
  
  TString newkey(key);
  
  newkey.ReplaceAll(source,dest);

  TPair* pair = static_cast<TPair*>(sourceMap.FindObject(key.Data()));

  destMap.Add(new TObjString(newkey.Data()),pair->Value());
}

//_____________________________________________________________________________
void AliMUONCalibrationData::PatchSt1DCSAliases(TMap& hvMap)
{
  /// It was discovered (in sept. 2013) that the DCS aliases for St1 was
  /// wrongly assigned (in the hardware), so the correspondence between DCS channels
  /// and actual HV channels is wrong for St1 in the DCS (and thus in the DCS archive,
  /// and so in the OCDB HV object).
  ///
  /// It affects all the OCDB object written in 2010-2013.
  ///
  /// This method fixes that.
  
  if ( hvMap.GetUniqueID() == fgkDCSSt1Flag )
  {
    // already clean object. Do nothing
    return;
  }

  TIter next(&hvMap);
  TObjString* hvChannelName;
  
  TMap newmap;
  newmap.SetOwnerKeyValue(kTRUE,kFALSE);
  
  while ( ( hvChannelName = static_cast<TObjString*>(next()) ) )
  {
    TString name(hvChannelName->String());
    TString newname(name);
    
    // the problem is limited to St1 = ch1+ch2 (or, in DCS parlance, ch0+ch1)
    // do it "by hand" as we "only" have 8 names to change
    
    if ( name.Contains("Chamber00Left") )
    {
      if (name.Contains("Quad1Sect0")) AddToMap(hvMap,newmap,name,"Quad1Sect0","Quad2Sect0"); // channel 0 of Board00 (alidcscae020)
      
      if (name.Contains("Quad1Sect1")) AddToMap(hvMap,newmap,name,"Quad1Sect1","Quad2Sect1"); // channel 1
      if (name.Contains("Quad1Sect2")) AddToMap(hvMap,newmap,name,"Quad1Sect2","Quad2Sect2"); // channel 2
      
      if (name.Contains("Quad2Sect2")) AddToMap(hvMap,newmap,name,"Quad2Sect2","Quad1Sect0"); // channel 3
      if (name.Contains("Quad2Sect1")) AddToMap(hvMap,newmap,name,"Quad2Sect1","Quad1Sect1"); // channel 4
      if (name.Contains("Quad2Sect0")) AddToMap(hvMap,newmap,name,"Quad2Sect0","Quad1Sect2"); // channel 5
    }
    else if ( name.Contains("Chamber01Left"))
    {
      if (name.Contains("Quad2Sect2")) AddToMap(hvMap,newmap,name,"Quad2Sect2","Quad2Sect0"); // channel 9 of Board00 (alidcscae020)
      if (name.Contains("Quad2Sect0")) AddToMap(hvMap,newmap,name,"Quad2Sect0","Quad2Sect2"); // channel 11
    }
    else
    {
      AddToMap(hvMap,newmap,name,name,name);
    }
  }
  
  // copy newmap to hvMap
  
  TIter nextNewMap(&newmap);
  while ( ( hvChannelName = static_cast<TObjString*>(nextNewMap()) ) )
  {
    TPair* oldPair = static_cast<TPair*>(hvMap.FindObject(hvChannelName->String().Data()));
    TPair* newPair = static_cast<TPair*>(newmap.FindObject(hvChannelName->String().Data()));
      
    TObjArray* newValues = static_cast<TObjArray*>(newPair->Value());
      
    oldPair->SetValue(newValues);
  }
}

//_____________________________________________________________________________
TMap*
AliMUONCalibrationData::CreateHV(Int_t runNumber, 
                                 Int_t* startOfValidity, 
                                 Bool_t patched,
                                 TList* messages,
                                 Bool_t dryRun)
{
  /// Create a new HV map from the OCDB for a given run
  ///
  /// dryRun is only usefull with patched=kTRUE and non-empty messages) :
  /// it allow to get the list of messages without altering the values at all
  /// (A patch without a patch, so to speak...)
  ///
  
  TMap* hvMap = dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/HV",startOfValidity));

  if (!hvMap) return 0x0;

  PatchSt1DCSAliases(*hvMap);
  
  if (patched)
  {
    TIter next(hvMap);
    TObjString* hvChannelName;
    
    while ( ( hvChannelName = static_cast<TObjString*>(next()) ) )
    {
      TString name(hvChannelName->String());
      
      if ( name.Contains("sw") ) continue; // skip switches

      if ( name.Contains("iMon") ) continue; // skip HV currents

      TPair* hvPair = static_cast<TPair*>(hvMap->FindObject(name.Data()));
      TObjArray* values = static_cast<TObjArray*>(hvPair->Value());
      if (!values)
      {
        AliErrorClass(Form("Could not get values for alias %s",name.Data()));
      }
      else
      {
        TString msg;
        
        AliDebugClass(1,Form("channel %s",name.Data()));
        Bool_t ok = PatchHVValues(*values,&msg,dryRun);
        
        if ( messages ) 
        {
          messages->Add(new TObjString(Form("%s %s",hvChannelName->String().Data(),msg.Data())));
        }
        
        if (!ok)
        {
          AliErrorClass(Form("PatchHVValue was not successfull ! This is serious ! "
                             "You'll have to check the logic for channel %s in run %09d",
                             name.Data(),runNumber));
        }
      }
    }
    
  }
  
  if ( messages ) 
  {
    Int_t a(0),b(0),c(0),d(0),e(0),f(0),g(0),h(0),u(0),z(0);
    TIter next(messages);
    TObjString* msg;
    char hvCase('u');
    
    while ( ( msg = static_cast<TObjString*>(next()) ) )
    {
      Int_t i = msg->String().Index("CASE",strlen("CASE"),0,TString::kExact);
      
      if ( i >= 0 )
      {
        sscanf(msg->String()(i,msg->String().Length()-i).Data(),"CASE:%10c",&hvCase);
      }

      switch (hvCase)
      {
        case 'A': ++a; break;
        case 'B': ++b; break;
        case 'C': ++c; break;
        case 'D': ++d; break;
        case 'E': ++e; break;
        case 'F': ++f; break;
        case 'G': ++g; break;
        case 'H': ++h; break;
        case 'Z': ++z; break;
        default: ++u; break;
      }
    }
    
    messages->Add(new TObjString(Form("SUMMARY : # of cases A(%3d) B(%3d) C(%3d) D(%3d) E(%3d) F(%3d) G(%3d) H(%3d) Z(%3d) OTHER(%3d)",
                                      a,b,c,d,e,f,g,h,z,u)));
  }
  
  return hvMap;
}

//_____________________________________________________________________________
TMap*
AliMUONCalibrationData::CreateTriggerDCS(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a new Trigger HV and curent map from the OCDB for a given run
  return dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/TriggerDCS",startOfValidity));
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreateLocalTriggerBoardMasks(Int_t runNumber, Int_t* startOfValidity)
{
  /// Get the internal store for LocalTriggerBoardMasks from OCDB
  
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/LocalTriggerBoardMasks",startOfValidity));
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreateNeighbours(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a neighbour store from the OCDB for a given run
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Neighbours",startOfValidity));
}

//_____________________________________________________________________________
TObject*
AliMUONCalibrationData::CreateObject(Int_t runNumber, const char* path, Int_t* startOfValidity)
{
  /// Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
  /// and return the corresponding TObject.
  
  AliCodeTimerAutoClass(Form("%09d : %s",runNumber,path),0);
  
  AliCDBManager* man = AliCDBManager::Instance();
  
  AliCDBEntry* entry =  man->Get(path,runNumber);
  
  if (entry)
  {
		if ( startOfValidity ) *startOfValidity = entry->GetId().GetFirstRun();
		
    TObject* object = entry->GetObject();
    if (!(man->GetCacheFlag()))
    {
      entry->SetOwner(kFALSE);
      delete entry;      
    }
//    else
//    {
//      entry->SetOwner(kTRUE); //FIXME : this should be done but is causing problems with RecoParams at the end of the reco : investigate why...
//    }
    return object;
  }
	else
	{
		if ( startOfValidity )  *startOfValidity = AliCDBRunRange::Infinity();
  }
	
  {
    
    AliCodeTimerAutoClass(Form("Failed to get %s for run %09d",path,runNumber),1);

  }
  
  return 0x0;
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreateOccupancyMap(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a new occupancy map store from the OCDB for a given run
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/OccupancyMap",startOfValidity));
}

//_____________________________________________________________________________
AliMUONRejectList*
AliMUONCalibrationData::CreateRejectList(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a new rejectlist store from the OCDB for a given run
  return dynamic_cast<AliMUONRejectList*>(CreateObject(runNumber,"MUON/Calib/RejectList",startOfValidity));
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreatePedestals(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a new pedestal store from the OCDB for a given run
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Pedestals",startOfValidity));
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreateConfig(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create a new config store from the OCDB for a given run
  return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Config",startOfValidity));
}


//_____________________________________________________________________________
AliMUONRegionalTriggerConfig*
AliMUONCalibrationData::CreateRegionalTriggerConfig(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create the internal store for RegionalTriggerConfig from OCDB
  
  return dynamic_cast<AliMUONRegionalTriggerConfig*>(CreateObject(runNumber,"MUON/Calib/RegionalTriggerConfig",startOfValidity));
}

//_____________________________________________________________________________
AliMUONTriggerEfficiencyCells* 
AliMUONCalibrationData::CreateTriggerEfficiency(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create trigger efficiency object from OCBD
  
  return dynamic_cast<AliMUONTriggerEfficiencyCells*>(CreateObject(runNumber,"MUON/Calib/TriggerEfficiency",startOfValidity));
}

//_____________________________________________________________________________
AliMUONTriggerLut* 
AliMUONCalibrationData::CreateTriggerLut(Int_t runNumber, Int_t* startOfValidity)
{
  /// Create trigger LUT from OCDB
  
  return dynamic_cast<AliMUONTriggerLut*>(CreateObject(runNumber,"MUON/Calib/TriggerLut",startOfValidity));
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::Gains() const
{
  /// Create (if needed) and return the internal store for gains.
  if (fgBypassGains) return fgBypassGains;
  
  if (!fGains)
  {
    fGains = CreateGains(fRunNumber);
  }
  return fGains;
}
 
//_____________________________________________________________________________
AliMUONVCalibParam*
AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const
{
/// Return the gains for a given (detElemId, manuId) pair
/// Note that, unlike the DeadChannel case, if the result is 0x0, that's an
/// error (meaning that we should get gains for all channels).

  AliMUONVStore* gains = Gains();
  if (!gains)
  {
    return 0x0;
  }
  
  return static_cast<AliMUONVCalibParam*>(gains->FindObject(detElemId,manuId));
}

//_____________________________________________________________________________
AliMUONGlobalCrateConfig* 
AliMUONCalibrationData::GlobalTriggerCrateConfig() const
{
  /// Return the config for the global trigger board.
  
  if (!fGlobalTriggerCrateConfig)
  {
    fGlobalTriggerCrateConfig = CreateGlobalTriggerCrateConfig(fRunNumber);
  }
  return fGlobalTriggerCrateConfig;
}


//_____________________________________________________________________________
TMap*
AliMUONCalibrationData::HV(Bool_t patched) const
{
  /// Return the calibration for a given (detElemId, manuId) pair
  
  if (!fHV)
  {
    fHV = CreateHV(fRunNumber,0,patched);
  }
  return fHV;
}

//_____________________________________________________________________________
TMap*
AliMUONCalibrationData::TriggerDCS() const
{
  /// Return the calibration for a given (detElemId, manuId) pair
  
  if (!fTriggerDCS)
  {
    fTriggerDCS = CreateTriggerDCS(fRunNumber);
  }
  return fTriggerDCS;
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::Neighbours() const
{
  /// Create (if needed) and return the internal store for neighbours.
  if (!fNeighbours)
  {
    fNeighbours = CreateNeighbours(fRunNumber);
  }
  return fNeighbours;
}

//_____________________________________________________________________________
AliMUONVCalibParam* 
AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
{
/// Return the masks for a given trigger local board.

  if (!fLocalTriggerBoardMasks)
  {
    fLocalTriggerBoardMasks = CreateLocalTriggerBoardMasks(fRunNumber);
  }

  if ( fLocalTriggerBoardMasks ) 
  {
    AliMUONVCalibParam* ltbm = 
      static_cast<AliMUONVCalibParam*>(fLocalTriggerBoardMasks->FindObject(localBoardNumber));
    if (!ltbm)
    {
      AliError(Form("Could not get mask for localBoardNumber=%d",localBoardNumber));
    }
    return ltbm;  
  }
  return 0x0;
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::OccupancyMap() const
{
  /// Get occupancy map
  if (!fOccupancyMap)
  {
    fOccupancyMap = CreateOccupancyMap(fRunNumber);
  }
  return fOccupancyMap;
}

//_____________________________________________________________________________
AliMUONRejectList*
AliMUONCalibrationData::RejectList() const
{
  /// Get reject list
  if (!fRejectList)
  {
    fRejectList = CreateRejectList(fRunNumber);
  }
  return fRejectList;
}

//_____________________________________________________________________________
void
AliMUONCalibrationData::BypassStores(AliMUONVStore* ped, AliMUONVStore* gain)
{
  /// Force the use of those pedestals and gains
  fgBypassPedestals = ped;
  fgBypassGains = gain;
  
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::Pedestals() const
{
  /// Return pedestals
  
  if (fgBypassPedestals) return fgBypassPedestals;
  
  if (!fPedestals)
  {
    fPedestals = CreatePedestals(fRunNumber);
  }
  return fPedestals;
}

//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::Config() const
{
  /// Return config
  
  if (!fConfig)
  {
    fConfig = CreateConfig(fRunNumber);
  }
  return fConfig;
}

//_____________________________________________________________________________
AliMUONVCalibParam*
AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const
{
  /// Return the pedestals for a given (detElemId, manuId) pair.
  /// A return value of 0x0 is considered an error, meaning we should get
  /// pedestals for all channels.
  
  AliMUONVStore* pedestals = Pedestals();
  if (!pedestals) 
  {
    return 0x0;
  }
  
  return static_cast<AliMUONVCalibParam*>(pedestals->FindObject(detElemId,manuId));
}

//_____________________________________________________________________________
void
AliMUONCalibrationData::Print(Option_t*) const
{
  /// A very basic dump of our guts.

  cout << "RunNumber " << RunNumber()
  << " fGains=" << fGains
  << " fPedestals=" << fPedestals
  << " fConfig=" << fConfig
  << " fHV=" << fHV
  << " fTriggerDCS=" << fTriggerDCS
  << " fLocalTriggerBoardMasks=" << fLocalTriggerBoardMasks
  << " fRegionalTriggerConfig=" << fRegionalTriggerConfig
  << " fGlobalTriggerCrateConfig=" << fGlobalTriggerCrateConfig
  << " fTriggerLut=" << fTriggerLut
  << endl;
}


//_____________________________________________________________________________
AliMUONRegionalTriggerConfig* 
AliMUONCalibrationData::RegionalTriggerConfig() const
{
  /// Return the config for the regional trigger board.
  
  if (!fRegionalTriggerConfig)
  {
    fRegionalTriggerConfig = CreateRegionalTriggerConfig(fRunNumber);
    }
  return fRegionalTriggerConfig;
}


//_____________________________________________________________________________
AliMUONTriggerEfficiencyCells*
AliMUONCalibrationData::TriggerEfficiency() const
{
/// Return the trigger efficiency.

  if (!fTriggerEfficiency)
  {
    fTriggerEfficiency = CreateTriggerEfficiency(fRunNumber);
  }
  return fTriggerEfficiency;
}


//_____________________________________________________________________________
AliMUONTriggerLut*
AliMUONCalibrationData::TriggerLut() const
{
/// Return the trigger look up table.

  if (!fTriggerLut)
  {
    fTriggerLut = CreateTriggerLut(fRunNumber);
  }
  return fTriggerLut;
}

//_____________________________________________________________________________
void
AliMUONCalibrationData::Reset()
{
/// Reset all data

  AliCodeTimerAuto("",0);
  
  delete fConfig;
  fConfig = 0x0;
  delete fPedestals;
  fPedestals = 0x0;
  delete fGains;
  fGains = 0x0;
  delete fHV;
  fHV = 0x0;
  delete fTriggerDCS;
  fTriggerDCS = 0x0;
  delete fLocalTriggerBoardMasks;
  fLocalTriggerBoardMasks = 0x0;
  delete fRegionalTriggerConfig;
  fRegionalTriggerConfig = 0x0;
  delete fGlobalTriggerCrateConfig;
  fGlobalTriggerCrateConfig = 0x0;
  
  delete fTriggerLut;
  fTriggerLut = 0x0;
  delete fTriggerEfficiency;
  fTriggerEfficiency = 0x0;
  delete fCapacitances;
  fCapacitances = 0x0;
  delete fNeighbours;
  fNeighbours = 0x0;
}

//_____________________________________________________________________________
void
AliMUONCalibrationData::Check(Int_t runNumber)
{
  /// Self-check to see if we can read all data for a given run 
  /// from the current OCDB...
  
  if ( ! CreateCapacitances(runNumber) )
  {
    AliErrorClass("Could not read capacitances");
  }
  else
  {
    AliInfoClass("Capacitances read OK");
  }

  if ( ! CreateGains(runNumber) ) 
  {
    AliErrorClass("Could not read gains");
  }
  else
  {
    AliInfoClass("Gains read OK");
  }

  if ( ! CreateGlobalTriggerCrateConfig(runNumber) ) 
  {
    AliErrorClass("Could not read Trigger Crate Config");
  }
  else
  {
    AliInfoClass("TriggerBoardMasks read OK");
  }

  if ( !  CreateHV(runNumber) )
  {
    AliErrorClass("Could not read HV");
  }
  else
  {
    AliInfoClass("HV read OK");
  }

  if ( !  CreateTriggerDCS(runNumber) )
  {
    AliErrorClass("Could not read Trigger HV and Currents");
  }
  else
  {
    AliInfoClass("Trigger HV and Currents read OK");
  }

  if ( ! CreateNeighbours(runNumber) )
  {
    AliErrorClass("Could not read Neighbours");
  }
  else
  {
    AliInfoClass("Neighbours read OK");
  }

  if ( !  CreateLocalTriggerBoardMasks(runNumber) )
  {
    AliErrorClass("Could not read LocalTriggerBoardMasks");
  }
  else
  {
    AliInfoClass("LocalTriggerBoardMasks read OK");
  }
  
  if ( ! CreatePedestals(runNumber) )
  {
    AliErrorClass("Could not read pedestals");
  }
  else
  {
    AliInfoClass("Pedestals read OK");
  }

  if ( ! CreateConfig(runNumber) )
  {
    AliErrorClass("Could not read config");
  }
  else
  {
    AliInfoClass("Config read OK");
  }
  
  if ( ! CreateRegionalTriggerConfig(runNumber) )
  {
    AliErrorClass("Could not read RegionalTriggerConfig");
  }
  else
  {
    AliInfoClass("RegionalTriggerBoardMasks read OK");
  }
  
  if ( ! CreateTriggerLut(runNumber) )
  {
    AliErrorClass("Could not read TriggerLut");
  }
  else
  {
    AliInfoClass("TriggerLut read OK");
  }

  if ( ! CreateTriggerEfficiency(runNumber) )
  {
    AliErrorClass("Could not read TriggerEfficiency");
  }
  else    
  {
    AliInfoClass("TriggerEfficiency read OK");
  }
}
 AliMUONCalibrationData.cxx:1
 AliMUONCalibrationData.cxx:2
 AliMUONCalibrationData.cxx:3
 AliMUONCalibrationData.cxx:4
 AliMUONCalibrationData.cxx:5
 AliMUONCalibrationData.cxx:6
 AliMUONCalibrationData.cxx:7
 AliMUONCalibrationData.cxx:8
 AliMUONCalibrationData.cxx:9
 AliMUONCalibrationData.cxx:10
 AliMUONCalibrationData.cxx:11
 AliMUONCalibrationData.cxx:12
 AliMUONCalibrationData.cxx:13
 AliMUONCalibrationData.cxx:14
 AliMUONCalibrationData.cxx:15
 AliMUONCalibrationData.cxx:16
 AliMUONCalibrationData.cxx:17
 AliMUONCalibrationData.cxx:18
 AliMUONCalibrationData.cxx:19
 AliMUONCalibrationData.cxx:20
 AliMUONCalibrationData.cxx:21
 AliMUONCalibrationData.cxx:22
 AliMUONCalibrationData.cxx:23
 AliMUONCalibrationData.cxx:24
 AliMUONCalibrationData.cxx:25
 AliMUONCalibrationData.cxx:26
 AliMUONCalibrationData.cxx:27
 AliMUONCalibrationData.cxx:28
 AliMUONCalibrationData.cxx:29
 AliMUONCalibrationData.cxx:30
 AliMUONCalibrationData.cxx:31
 AliMUONCalibrationData.cxx:32
 AliMUONCalibrationData.cxx:33
 AliMUONCalibrationData.cxx:34
 AliMUONCalibrationData.cxx:35
 AliMUONCalibrationData.cxx:36
 AliMUONCalibrationData.cxx:37
 AliMUONCalibrationData.cxx:38
 AliMUONCalibrationData.cxx:39
 AliMUONCalibrationData.cxx:40
 AliMUONCalibrationData.cxx:41
 AliMUONCalibrationData.cxx:42
 AliMUONCalibrationData.cxx:43
 AliMUONCalibrationData.cxx:44
 AliMUONCalibrationData.cxx:45
 AliMUONCalibrationData.cxx:46
 AliMUONCalibrationData.cxx:47
 AliMUONCalibrationData.cxx:48
 AliMUONCalibrationData.cxx:49
 AliMUONCalibrationData.cxx:50
 AliMUONCalibrationData.cxx:51
 AliMUONCalibrationData.cxx:52
 AliMUONCalibrationData.cxx:53
 AliMUONCalibrationData.cxx:54
 AliMUONCalibrationData.cxx:55
 AliMUONCalibrationData.cxx:56
 AliMUONCalibrationData.cxx:57
 AliMUONCalibrationData.cxx:58
 AliMUONCalibrationData.cxx:59
 AliMUONCalibrationData.cxx:60
 AliMUONCalibrationData.cxx:61
 AliMUONCalibrationData.cxx:62
 AliMUONCalibrationData.cxx:63
 AliMUONCalibrationData.cxx:64
 AliMUONCalibrationData.cxx:65
 AliMUONCalibrationData.cxx:66
 AliMUONCalibrationData.cxx:67
 AliMUONCalibrationData.cxx:68
 AliMUONCalibrationData.cxx:69
 AliMUONCalibrationData.cxx:70
 AliMUONCalibrationData.cxx:71
 AliMUONCalibrationData.cxx:72
 AliMUONCalibrationData.cxx:73
 AliMUONCalibrationData.cxx:74
 AliMUONCalibrationData.cxx:75
 AliMUONCalibrationData.cxx:76
 AliMUONCalibrationData.cxx:77
 AliMUONCalibrationData.cxx:78
 AliMUONCalibrationData.cxx:79
 AliMUONCalibrationData.cxx:80
 AliMUONCalibrationData.cxx:81
 AliMUONCalibrationData.cxx:82
 AliMUONCalibrationData.cxx:83
 AliMUONCalibrationData.cxx:84
 AliMUONCalibrationData.cxx:85
 AliMUONCalibrationData.cxx:86
 AliMUONCalibrationData.cxx:87
 AliMUONCalibrationData.cxx:88
 AliMUONCalibrationData.cxx:89
 AliMUONCalibrationData.cxx:90
 AliMUONCalibrationData.cxx:91
 AliMUONCalibrationData.cxx:92
 AliMUONCalibrationData.cxx:93
 AliMUONCalibrationData.cxx:94
 AliMUONCalibrationData.cxx:95
 AliMUONCalibrationData.cxx:96
 AliMUONCalibrationData.cxx:97
 AliMUONCalibrationData.cxx:98
 AliMUONCalibrationData.cxx:99
 AliMUONCalibrationData.cxx:100
 AliMUONCalibrationData.cxx:101
 AliMUONCalibrationData.cxx:102
 AliMUONCalibrationData.cxx:103
 AliMUONCalibrationData.cxx:104
 AliMUONCalibrationData.cxx:105
 AliMUONCalibrationData.cxx:106
 AliMUONCalibrationData.cxx:107
 AliMUONCalibrationData.cxx:108
 AliMUONCalibrationData.cxx:109
 AliMUONCalibrationData.cxx:110
 AliMUONCalibrationData.cxx:111
 AliMUONCalibrationData.cxx:112
 AliMUONCalibrationData.cxx:113
 AliMUONCalibrationData.cxx:114
 AliMUONCalibrationData.cxx:115
 AliMUONCalibrationData.cxx:116
 AliMUONCalibrationData.cxx:117
 AliMUONCalibrationData.cxx:118
 AliMUONCalibrationData.cxx:119
 AliMUONCalibrationData.cxx:120
 AliMUONCalibrationData.cxx:121
 AliMUONCalibrationData.cxx:122
 AliMUONCalibrationData.cxx:123
 AliMUONCalibrationData.cxx:124
 AliMUONCalibrationData.cxx:125
 AliMUONCalibrationData.cxx:126
 AliMUONCalibrationData.cxx:127
 AliMUONCalibrationData.cxx:128
 AliMUONCalibrationData.cxx:129
 AliMUONCalibrationData.cxx:130
 AliMUONCalibrationData.cxx:131
 AliMUONCalibrationData.cxx:132
 AliMUONCalibrationData.cxx:133
 AliMUONCalibrationData.cxx:134
 AliMUONCalibrationData.cxx:135
 AliMUONCalibrationData.cxx:136
 AliMUONCalibrationData.cxx:137
 AliMUONCalibrationData.cxx:138
 AliMUONCalibrationData.cxx:139
 AliMUONCalibrationData.cxx:140
 AliMUONCalibrationData.cxx:141
 AliMUONCalibrationData.cxx:142
 AliMUONCalibrationData.cxx:143
 AliMUONCalibrationData.cxx:144
 AliMUONCalibrationData.cxx:145
 AliMUONCalibrationData.cxx:146
 AliMUONCalibrationData.cxx:147
 AliMUONCalibrationData.cxx:148
 AliMUONCalibrationData.cxx:149
 AliMUONCalibrationData.cxx:150
 AliMUONCalibrationData.cxx:151
 AliMUONCalibrationData.cxx:152
 AliMUONCalibrationData.cxx:153
 AliMUONCalibrationData.cxx:154
 AliMUONCalibrationData.cxx:155
 AliMUONCalibrationData.cxx:156
 AliMUONCalibrationData.cxx:157
 AliMUONCalibrationData.cxx:158
 AliMUONCalibrationData.cxx:159
 AliMUONCalibrationData.cxx:160
 AliMUONCalibrationData.cxx:161
 AliMUONCalibrationData.cxx:162
 AliMUONCalibrationData.cxx:163
 AliMUONCalibrationData.cxx:164
 AliMUONCalibrationData.cxx:165
 AliMUONCalibrationData.cxx:166
 AliMUONCalibrationData.cxx:167
 AliMUONCalibrationData.cxx:168
 AliMUONCalibrationData.cxx:169
 AliMUONCalibrationData.cxx:170
 AliMUONCalibrationData.cxx:171
 AliMUONCalibrationData.cxx:172
 AliMUONCalibrationData.cxx:173
 AliMUONCalibrationData.cxx:174
 AliMUONCalibrationData.cxx:175
 AliMUONCalibrationData.cxx:176
 AliMUONCalibrationData.cxx:177
 AliMUONCalibrationData.cxx:178
 AliMUONCalibrationData.cxx:179
 AliMUONCalibrationData.cxx:180
 AliMUONCalibrationData.cxx:181
 AliMUONCalibrationData.cxx:182
 AliMUONCalibrationData.cxx:183
 AliMUONCalibrationData.cxx:184
 AliMUONCalibrationData.cxx:185
 AliMUONCalibrationData.cxx:186
 AliMUONCalibrationData.cxx:187
 AliMUONCalibrationData.cxx:188
 AliMUONCalibrationData.cxx:189
 AliMUONCalibrationData.cxx:190
 AliMUONCalibrationData.cxx:191
 AliMUONCalibrationData.cxx:192
 AliMUONCalibrationData.cxx:193
 AliMUONCalibrationData.cxx:194
 AliMUONCalibrationData.cxx:195
 AliMUONCalibrationData.cxx:196
 AliMUONCalibrationData.cxx:197
 AliMUONCalibrationData.cxx:198
 AliMUONCalibrationData.cxx:199
 AliMUONCalibrationData.cxx:200
 AliMUONCalibrationData.cxx:201
 AliMUONCalibrationData.cxx:202
 AliMUONCalibrationData.cxx:203
 AliMUONCalibrationData.cxx:204
 AliMUONCalibrationData.cxx:205
 AliMUONCalibrationData.cxx:206
 AliMUONCalibrationData.cxx:207
 AliMUONCalibrationData.cxx:208
 AliMUONCalibrationData.cxx:209
 AliMUONCalibrationData.cxx:210
 AliMUONCalibrationData.cxx:211
 AliMUONCalibrationData.cxx:212
 AliMUONCalibrationData.cxx:213
 AliMUONCalibrationData.cxx:214
 AliMUONCalibrationData.cxx:215
 AliMUONCalibrationData.cxx:216
 AliMUONCalibrationData.cxx:217
 AliMUONCalibrationData.cxx:218
 AliMUONCalibrationData.cxx:219
 AliMUONCalibrationData.cxx:220
 AliMUONCalibrationData.cxx:221
 AliMUONCalibrationData.cxx:222
 AliMUONCalibrationData.cxx:223
 AliMUONCalibrationData.cxx:224
 AliMUONCalibrationData.cxx:225
 AliMUONCalibrationData.cxx:226
 AliMUONCalibrationData.cxx:227
 AliMUONCalibrationData.cxx:228
 AliMUONCalibrationData.cxx:229
 AliMUONCalibrationData.cxx:230
 AliMUONCalibrationData.cxx:231
 AliMUONCalibrationData.cxx:232
 AliMUONCalibrationData.cxx:233
 AliMUONCalibrationData.cxx:234
 AliMUONCalibrationData.cxx:235
 AliMUONCalibrationData.cxx:236
 AliMUONCalibrationData.cxx:237
 AliMUONCalibrationData.cxx:238
 AliMUONCalibrationData.cxx:239
 AliMUONCalibrationData.cxx:240
 AliMUONCalibrationData.cxx:241
 AliMUONCalibrationData.cxx:242
 AliMUONCalibrationData.cxx:243
 AliMUONCalibrationData.cxx:244
 AliMUONCalibrationData.cxx:245
 AliMUONCalibrationData.cxx:246
 AliMUONCalibrationData.cxx:247
 AliMUONCalibrationData.cxx:248
 AliMUONCalibrationData.cxx:249
 AliMUONCalibrationData.cxx:250
 AliMUONCalibrationData.cxx:251
 AliMUONCalibrationData.cxx:252
 AliMUONCalibrationData.cxx:253
 AliMUONCalibrationData.cxx:254
 AliMUONCalibrationData.cxx:255
 AliMUONCalibrationData.cxx:256
 AliMUONCalibrationData.cxx:257
 AliMUONCalibrationData.cxx:258
 AliMUONCalibrationData.cxx:259
 AliMUONCalibrationData.cxx:260
 AliMUONCalibrationData.cxx:261
 AliMUONCalibrationData.cxx:262
 AliMUONCalibrationData.cxx:263
 AliMUONCalibrationData.cxx:264
 AliMUONCalibrationData.cxx:265
 AliMUONCalibrationData.cxx:266
 AliMUONCalibrationData.cxx:267
 AliMUONCalibrationData.cxx:268
 AliMUONCalibrationData.cxx:269
 AliMUONCalibrationData.cxx:270
 AliMUONCalibrationData.cxx:271
 AliMUONCalibrationData.cxx:272
 AliMUONCalibrationData.cxx:273
 AliMUONCalibrationData.cxx:274
 AliMUONCalibrationData.cxx:275
 AliMUONCalibrationData.cxx:276
 AliMUONCalibrationData.cxx:277
 AliMUONCalibrationData.cxx:278
 AliMUONCalibrationData.cxx:279
 AliMUONCalibrationData.cxx:280
 AliMUONCalibrationData.cxx:281
 AliMUONCalibrationData.cxx:282
 AliMUONCalibrationData.cxx:283
 AliMUONCalibrationData.cxx:284
 AliMUONCalibrationData.cxx:285
 AliMUONCalibrationData.cxx:286
 AliMUONCalibrationData.cxx:287
 AliMUONCalibrationData.cxx:288
 AliMUONCalibrationData.cxx:289
 AliMUONCalibrationData.cxx:290
 AliMUONCalibrationData.cxx:291
 AliMUONCalibrationData.cxx:292
 AliMUONCalibrationData.cxx:293
 AliMUONCalibrationData.cxx:294
 AliMUONCalibrationData.cxx:295
 AliMUONCalibrationData.cxx:296
 AliMUONCalibrationData.cxx:297
 AliMUONCalibrationData.cxx:298
 AliMUONCalibrationData.cxx:299
 AliMUONCalibrationData.cxx:300
 AliMUONCalibrationData.cxx:301
 AliMUONCalibrationData.cxx:302
 AliMUONCalibrationData.cxx:303
 AliMUONCalibrationData.cxx:304
 AliMUONCalibrationData.cxx:305
 AliMUONCalibrationData.cxx:306
 AliMUONCalibrationData.cxx:307
 AliMUONCalibrationData.cxx:308
 AliMUONCalibrationData.cxx:309
 AliMUONCalibrationData.cxx:310
 AliMUONCalibrationData.cxx:311
 AliMUONCalibrationData.cxx:312
 AliMUONCalibrationData.cxx:313
 AliMUONCalibrationData.cxx:314
 AliMUONCalibrationData.cxx:315
 AliMUONCalibrationData.cxx:316
 AliMUONCalibrationData.cxx:317
 AliMUONCalibrationData.cxx:318
 AliMUONCalibrationData.cxx:319
 AliMUONCalibrationData.cxx:320
 AliMUONCalibrationData.cxx:321
 AliMUONCalibrationData.cxx:322
 AliMUONCalibrationData.cxx:323
 AliMUONCalibrationData.cxx:324
 AliMUONCalibrationData.cxx:325
 AliMUONCalibrationData.cxx:326
 AliMUONCalibrationData.cxx:327
 AliMUONCalibrationData.cxx:328
 AliMUONCalibrationData.cxx:329
 AliMUONCalibrationData.cxx:330
 AliMUONCalibrationData.cxx:331
 AliMUONCalibrationData.cxx:332
 AliMUONCalibrationData.cxx:333
 AliMUONCalibrationData.cxx:334
 AliMUONCalibrationData.cxx:335
 AliMUONCalibrationData.cxx:336
 AliMUONCalibrationData.cxx:337
 AliMUONCalibrationData.cxx:338
 AliMUONCalibrationData.cxx:339
 AliMUONCalibrationData.cxx:340
 AliMUONCalibrationData.cxx:341
 AliMUONCalibrationData.cxx:342
 AliMUONCalibrationData.cxx:343
 AliMUONCalibrationData.cxx:344
 AliMUONCalibrationData.cxx:345
 AliMUONCalibrationData.cxx:346
 AliMUONCalibrationData.cxx:347
 AliMUONCalibrationData.cxx:348
 AliMUONCalibrationData.cxx:349
 AliMUONCalibrationData.cxx:350
 AliMUONCalibrationData.cxx:351
 AliMUONCalibrationData.cxx:352
 AliMUONCalibrationData.cxx:353
 AliMUONCalibrationData.cxx:354
 AliMUONCalibrationData.cxx:355
 AliMUONCalibrationData.cxx:356
 AliMUONCalibrationData.cxx:357
 AliMUONCalibrationData.cxx:358
 AliMUONCalibrationData.cxx:359
 AliMUONCalibrationData.cxx:360
 AliMUONCalibrationData.cxx:361
 AliMUONCalibrationData.cxx:362
 AliMUONCalibrationData.cxx:363
 AliMUONCalibrationData.cxx:364
 AliMUONCalibrationData.cxx:365
 AliMUONCalibrationData.cxx:366
 AliMUONCalibrationData.cxx:367
 AliMUONCalibrationData.cxx:368
 AliMUONCalibrationData.cxx:369
 AliMUONCalibrationData.cxx:370
 AliMUONCalibrationData.cxx:371
 AliMUONCalibrationData.cxx:372
 AliMUONCalibrationData.cxx:373
 AliMUONCalibrationData.cxx:374
 AliMUONCalibrationData.cxx:375
 AliMUONCalibrationData.cxx:376
 AliMUONCalibrationData.cxx:377
 AliMUONCalibrationData.cxx:378
 AliMUONCalibrationData.cxx:379
 AliMUONCalibrationData.cxx:380
 AliMUONCalibrationData.cxx:381
 AliMUONCalibrationData.cxx:382
 AliMUONCalibrationData.cxx:383
 AliMUONCalibrationData.cxx:384
 AliMUONCalibrationData.cxx:385
 AliMUONCalibrationData.cxx:386
 AliMUONCalibrationData.cxx:387
 AliMUONCalibrationData.cxx:388
 AliMUONCalibrationData.cxx:389
 AliMUONCalibrationData.cxx:390
 AliMUONCalibrationData.cxx:391
 AliMUONCalibrationData.cxx:392
 AliMUONCalibrationData.cxx:393
 AliMUONCalibrationData.cxx:394
 AliMUONCalibrationData.cxx:395
 AliMUONCalibrationData.cxx:396
 AliMUONCalibrationData.cxx:397
 AliMUONCalibrationData.cxx:398
 AliMUONCalibrationData.cxx:399
 AliMUONCalibrationData.cxx:400
 AliMUONCalibrationData.cxx:401
 AliMUONCalibrationData.cxx:402
 AliMUONCalibrationData.cxx:403
 AliMUONCalibrationData.cxx:404
 AliMUONCalibrationData.cxx:405
 AliMUONCalibrationData.cxx:406
 AliMUONCalibrationData.cxx:407
 AliMUONCalibrationData.cxx:408
 AliMUONCalibrationData.cxx:409
 AliMUONCalibrationData.cxx:410
 AliMUONCalibrationData.cxx:411
 AliMUONCalibrationData.cxx:412
 AliMUONCalibrationData.cxx:413
 AliMUONCalibrationData.cxx:414
 AliMUONCalibrationData.cxx:415
 AliMUONCalibrationData.cxx:416
 AliMUONCalibrationData.cxx:417
 AliMUONCalibrationData.cxx:418
 AliMUONCalibrationData.cxx:419
 AliMUONCalibrationData.cxx:420
 AliMUONCalibrationData.cxx:421
 AliMUONCalibrationData.cxx:422
 AliMUONCalibrationData.cxx:423
 AliMUONCalibrationData.cxx:424
 AliMUONCalibrationData.cxx:425
 AliMUONCalibrationData.cxx:426
 AliMUONCalibrationData.cxx:427
 AliMUONCalibrationData.cxx:428
 AliMUONCalibrationData.cxx:429
 AliMUONCalibrationData.cxx:430
 AliMUONCalibrationData.cxx:431
 AliMUONCalibrationData.cxx:432
 AliMUONCalibrationData.cxx:433
 AliMUONCalibrationData.cxx:434
 AliMUONCalibrationData.cxx:435
 AliMUONCalibrationData.cxx:436
 AliMUONCalibrationData.cxx:437
 AliMUONCalibrationData.cxx:438
 AliMUONCalibrationData.cxx:439
 AliMUONCalibrationData.cxx:440
 AliMUONCalibrationData.cxx:441
 AliMUONCalibrationData.cxx:442
 AliMUONCalibrationData.cxx:443
 AliMUONCalibrationData.cxx:444
 AliMUONCalibrationData.cxx:445
 AliMUONCalibrationData.cxx:446
 AliMUONCalibrationData.cxx:447
 AliMUONCalibrationData.cxx:448
 AliMUONCalibrationData.cxx:449
 AliMUONCalibrationData.cxx:450
 AliMUONCalibrationData.cxx:451
 AliMUONCalibrationData.cxx:452
 AliMUONCalibrationData.cxx:453
 AliMUONCalibrationData.cxx:454
 AliMUONCalibrationData.cxx:455
 AliMUONCalibrationData.cxx:456
 AliMUONCalibrationData.cxx:457
 AliMUONCalibrationData.cxx:458
 AliMUONCalibrationData.cxx:459
 AliMUONCalibrationData.cxx:460
 AliMUONCalibrationData.cxx:461
 AliMUONCalibrationData.cxx:462
 AliMUONCalibrationData.cxx:463
 AliMUONCalibrationData.cxx:464
 AliMUONCalibrationData.cxx:465
 AliMUONCalibrationData.cxx:466
 AliMUONCalibrationData.cxx:467
 AliMUONCalibrationData.cxx:468
 AliMUONCalibrationData.cxx:469
 AliMUONCalibrationData.cxx:470
 AliMUONCalibrationData.cxx:471
 AliMUONCalibrationData.cxx:472
 AliMUONCalibrationData.cxx:473
 AliMUONCalibrationData.cxx:474
 AliMUONCalibrationData.cxx:475
 AliMUONCalibrationData.cxx:476
 AliMUONCalibrationData.cxx:477
 AliMUONCalibrationData.cxx:478
 AliMUONCalibrationData.cxx:479
 AliMUONCalibrationData.cxx:480
 AliMUONCalibrationData.cxx:481
 AliMUONCalibrationData.cxx:482
 AliMUONCalibrationData.cxx:483
 AliMUONCalibrationData.cxx:484
 AliMUONCalibrationData.cxx:485
 AliMUONCalibrationData.cxx:486
 AliMUONCalibrationData.cxx:487
 AliMUONCalibrationData.cxx:488
 AliMUONCalibrationData.cxx:489
 AliMUONCalibrationData.cxx:490
 AliMUONCalibrationData.cxx:491
 AliMUONCalibrationData.cxx:492
 AliMUONCalibrationData.cxx:493
 AliMUONCalibrationData.cxx:494
 AliMUONCalibrationData.cxx:495
 AliMUONCalibrationData.cxx:496
 AliMUONCalibrationData.cxx:497
 AliMUONCalibrationData.cxx:498
 AliMUONCalibrationData.cxx:499
 AliMUONCalibrationData.cxx:500
 AliMUONCalibrationData.cxx:501
 AliMUONCalibrationData.cxx:502
 AliMUONCalibrationData.cxx:503
 AliMUONCalibrationData.cxx:504
 AliMUONCalibrationData.cxx:505
 AliMUONCalibrationData.cxx:506
 AliMUONCalibrationData.cxx:507
 AliMUONCalibrationData.cxx:508
 AliMUONCalibrationData.cxx:509
 AliMUONCalibrationData.cxx:510
 AliMUONCalibrationData.cxx:511
 AliMUONCalibrationData.cxx:512
 AliMUONCalibrationData.cxx:513
 AliMUONCalibrationData.cxx:514
 AliMUONCalibrationData.cxx:515
 AliMUONCalibrationData.cxx:516
 AliMUONCalibrationData.cxx:517
 AliMUONCalibrationData.cxx:518
 AliMUONCalibrationData.cxx:519
 AliMUONCalibrationData.cxx:520
 AliMUONCalibrationData.cxx:521
 AliMUONCalibrationData.cxx:522
 AliMUONCalibrationData.cxx:523
 AliMUONCalibrationData.cxx:524
 AliMUONCalibrationData.cxx:525
 AliMUONCalibrationData.cxx:526
 AliMUONCalibrationData.cxx:527
 AliMUONCalibrationData.cxx:528
 AliMUONCalibrationData.cxx:529
 AliMUONCalibrationData.cxx:530
 AliMUONCalibrationData.cxx:531
 AliMUONCalibrationData.cxx:532
 AliMUONCalibrationData.cxx:533
 AliMUONCalibrationData.cxx:534
 AliMUONCalibrationData.cxx:535
 AliMUONCalibrationData.cxx:536
 AliMUONCalibrationData.cxx:537
 AliMUONCalibrationData.cxx:538
 AliMUONCalibrationData.cxx:539
 AliMUONCalibrationData.cxx:540
 AliMUONCalibrationData.cxx:541
 AliMUONCalibrationData.cxx:542
 AliMUONCalibrationData.cxx:543
 AliMUONCalibrationData.cxx:544
 AliMUONCalibrationData.cxx:545
 AliMUONCalibrationData.cxx:546
 AliMUONCalibrationData.cxx:547
 AliMUONCalibrationData.cxx:548
 AliMUONCalibrationData.cxx:549
 AliMUONCalibrationData.cxx:550
 AliMUONCalibrationData.cxx:551
 AliMUONCalibrationData.cxx:552
 AliMUONCalibrationData.cxx:553
 AliMUONCalibrationData.cxx:554
 AliMUONCalibrationData.cxx:555
 AliMUONCalibrationData.cxx:556
 AliMUONCalibrationData.cxx:557
 AliMUONCalibrationData.cxx:558
 AliMUONCalibrationData.cxx:559
 AliMUONCalibrationData.cxx:560
 AliMUONCalibrationData.cxx:561
 AliMUONCalibrationData.cxx:562
 AliMUONCalibrationData.cxx:563
 AliMUONCalibrationData.cxx:564
 AliMUONCalibrationData.cxx:565
 AliMUONCalibrationData.cxx:566
 AliMUONCalibrationData.cxx:567
 AliMUONCalibrationData.cxx:568
 AliMUONCalibrationData.cxx:569
 AliMUONCalibrationData.cxx:570
 AliMUONCalibrationData.cxx:571
 AliMUONCalibrationData.cxx:572
 AliMUONCalibrationData.cxx:573
 AliMUONCalibrationData.cxx:574
 AliMUONCalibrationData.cxx:575
 AliMUONCalibrationData.cxx:576
 AliMUONCalibrationData.cxx:577
 AliMUONCalibrationData.cxx:578
 AliMUONCalibrationData.cxx:579
 AliMUONCalibrationData.cxx:580
 AliMUONCalibrationData.cxx:581
 AliMUONCalibrationData.cxx:582
 AliMUONCalibrationData.cxx:583
 AliMUONCalibrationData.cxx:584
 AliMUONCalibrationData.cxx:585
 AliMUONCalibrationData.cxx:586
 AliMUONCalibrationData.cxx:587
 AliMUONCalibrationData.cxx:588
 AliMUONCalibrationData.cxx:589
 AliMUONCalibrationData.cxx:590
 AliMUONCalibrationData.cxx:591
 AliMUONCalibrationData.cxx:592
 AliMUONCalibrationData.cxx:593
 AliMUONCalibrationData.cxx:594
 AliMUONCalibrationData.cxx:595
 AliMUONCalibrationData.cxx:596
 AliMUONCalibrationData.cxx:597
 AliMUONCalibrationData.cxx:598
 AliMUONCalibrationData.cxx:599
 AliMUONCalibrationData.cxx:600
 AliMUONCalibrationData.cxx:601
 AliMUONCalibrationData.cxx:602
 AliMUONCalibrationData.cxx:603
 AliMUONCalibrationData.cxx:604
 AliMUONCalibrationData.cxx:605
 AliMUONCalibrationData.cxx:606
 AliMUONCalibrationData.cxx:607
 AliMUONCalibrationData.cxx:608
 AliMUONCalibrationData.cxx:609
 AliMUONCalibrationData.cxx:610
 AliMUONCalibrationData.cxx:611
 AliMUONCalibrationData.cxx:612
 AliMUONCalibrationData.cxx:613
 AliMUONCalibrationData.cxx:614
 AliMUONCalibrationData.cxx:615
 AliMUONCalibrationData.cxx:616
 AliMUONCalibrationData.cxx:617
 AliMUONCalibrationData.cxx:618
 AliMUONCalibrationData.cxx:619
 AliMUONCalibrationData.cxx:620
 AliMUONCalibrationData.cxx:621
 AliMUONCalibrationData.cxx:622
 AliMUONCalibrationData.cxx:623
 AliMUONCalibrationData.cxx:624
 AliMUONCalibrationData.cxx:625
 AliMUONCalibrationData.cxx:626
 AliMUONCalibrationData.cxx:627
 AliMUONCalibrationData.cxx:628
 AliMUONCalibrationData.cxx:629
 AliMUONCalibrationData.cxx:630
 AliMUONCalibrationData.cxx:631
 AliMUONCalibrationData.cxx:632
 AliMUONCalibrationData.cxx:633
 AliMUONCalibrationData.cxx:634
 AliMUONCalibrationData.cxx:635
 AliMUONCalibrationData.cxx:636
 AliMUONCalibrationData.cxx:637
 AliMUONCalibrationData.cxx:638
 AliMUONCalibrationData.cxx:639
 AliMUONCalibrationData.cxx:640
 AliMUONCalibrationData.cxx:641
 AliMUONCalibrationData.cxx:642
 AliMUONCalibrationData.cxx:643
 AliMUONCalibrationData.cxx:644
 AliMUONCalibrationData.cxx:645
 AliMUONCalibrationData.cxx:646
 AliMUONCalibrationData.cxx:647
 AliMUONCalibrationData.cxx:648
 AliMUONCalibrationData.cxx:649
 AliMUONCalibrationData.cxx:650
 AliMUONCalibrationData.cxx:651
 AliMUONCalibrationData.cxx:652
 AliMUONCalibrationData.cxx:653
 AliMUONCalibrationData.cxx:654
 AliMUONCalibrationData.cxx:655
 AliMUONCalibrationData.cxx:656
 AliMUONCalibrationData.cxx:657
 AliMUONCalibrationData.cxx:658
 AliMUONCalibrationData.cxx:659
 AliMUONCalibrationData.cxx:660
 AliMUONCalibrationData.cxx:661
 AliMUONCalibrationData.cxx:662
 AliMUONCalibrationData.cxx:663
 AliMUONCalibrationData.cxx:664
 AliMUONCalibrationData.cxx:665
 AliMUONCalibrationData.cxx:666
 AliMUONCalibrationData.cxx:667
 AliMUONCalibrationData.cxx:668
 AliMUONCalibrationData.cxx:669
 AliMUONCalibrationData.cxx:670
 AliMUONCalibrationData.cxx:671
 AliMUONCalibrationData.cxx:672
 AliMUONCalibrationData.cxx:673
 AliMUONCalibrationData.cxx:674
 AliMUONCalibrationData.cxx:675
 AliMUONCalibrationData.cxx:676
 AliMUONCalibrationData.cxx:677
 AliMUONCalibrationData.cxx:678
 AliMUONCalibrationData.cxx:679
 AliMUONCalibrationData.cxx:680
 AliMUONCalibrationData.cxx:681
 AliMUONCalibrationData.cxx:682
 AliMUONCalibrationData.cxx:683
 AliMUONCalibrationData.cxx:684
 AliMUONCalibrationData.cxx:685
 AliMUONCalibrationData.cxx:686
 AliMUONCalibrationData.cxx:687
 AliMUONCalibrationData.cxx:688
 AliMUONCalibrationData.cxx:689
 AliMUONCalibrationData.cxx:690
 AliMUONCalibrationData.cxx:691
 AliMUONCalibrationData.cxx:692
 AliMUONCalibrationData.cxx:693
 AliMUONCalibrationData.cxx:694
 AliMUONCalibrationData.cxx:695
 AliMUONCalibrationData.cxx:696
 AliMUONCalibrationData.cxx:697
 AliMUONCalibrationData.cxx:698
 AliMUONCalibrationData.cxx:699
 AliMUONCalibrationData.cxx:700
 AliMUONCalibrationData.cxx:701
 AliMUONCalibrationData.cxx:702
 AliMUONCalibrationData.cxx:703
 AliMUONCalibrationData.cxx:704
 AliMUONCalibrationData.cxx:705
 AliMUONCalibrationData.cxx:706
 AliMUONCalibrationData.cxx:707
 AliMUONCalibrationData.cxx:708
 AliMUONCalibrationData.cxx:709
 AliMUONCalibrationData.cxx:710
 AliMUONCalibrationData.cxx:711
 AliMUONCalibrationData.cxx:712
 AliMUONCalibrationData.cxx:713
 AliMUONCalibrationData.cxx:714
 AliMUONCalibrationData.cxx:715
 AliMUONCalibrationData.cxx:716
 AliMUONCalibrationData.cxx:717
 AliMUONCalibrationData.cxx:718
 AliMUONCalibrationData.cxx:719
 AliMUONCalibrationData.cxx:720
 AliMUONCalibrationData.cxx:721
 AliMUONCalibrationData.cxx:722
 AliMUONCalibrationData.cxx:723
 AliMUONCalibrationData.cxx:724
 AliMUONCalibrationData.cxx:725
 AliMUONCalibrationData.cxx:726
 AliMUONCalibrationData.cxx:727
 AliMUONCalibrationData.cxx:728
 AliMUONCalibrationData.cxx:729
 AliMUONCalibrationData.cxx:730
 AliMUONCalibrationData.cxx:731
 AliMUONCalibrationData.cxx:732
 AliMUONCalibrationData.cxx:733
 AliMUONCalibrationData.cxx:734
 AliMUONCalibrationData.cxx:735
 AliMUONCalibrationData.cxx:736
 AliMUONCalibrationData.cxx:737
 AliMUONCalibrationData.cxx:738
 AliMUONCalibrationData.cxx:739
 AliMUONCalibrationData.cxx:740
 AliMUONCalibrationData.cxx:741
 AliMUONCalibrationData.cxx:742
 AliMUONCalibrationData.cxx:743
 AliMUONCalibrationData.cxx:744
 AliMUONCalibrationData.cxx:745
 AliMUONCalibrationData.cxx:746
 AliMUONCalibrationData.cxx:747
 AliMUONCalibrationData.cxx:748
 AliMUONCalibrationData.cxx:749
 AliMUONCalibrationData.cxx:750
 AliMUONCalibrationData.cxx:751
 AliMUONCalibrationData.cxx:752
 AliMUONCalibrationData.cxx:753
 AliMUONCalibrationData.cxx:754
 AliMUONCalibrationData.cxx:755
 AliMUONCalibrationData.cxx:756
 AliMUONCalibrationData.cxx:757
 AliMUONCalibrationData.cxx:758
 AliMUONCalibrationData.cxx:759
 AliMUONCalibrationData.cxx:760
 AliMUONCalibrationData.cxx:761
 AliMUONCalibrationData.cxx:762
 AliMUONCalibrationData.cxx:763
 AliMUONCalibrationData.cxx:764
 AliMUONCalibrationData.cxx:765
 AliMUONCalibrationData.cxx:766
 AliMUONCalibrationData.cxx:767
 AliMUONCalibrationData.cxx:768
 AliMUONCalibrationData.cxx:769
 AliMUONCalibrationData.cxx:770
 AliMUONCalibrationData.cxx:771
 AliMUONCalibrationData.cxx:772
 AliMUONCalibrationData.cxx:773
 AliMUONCalibrationData.cxx:774
 AliMUONCalibrationData.cxx:775
 AliMUONCalibrationData.cxx:776
 AliMUONCalibrationData.cxx:777
 AliMUONCalibrationData.cxx:778
 AliMUONCalibrationData.cxx:779
 AliMUONCalibrationData.cxx:780
 AliMUONCalibrationData.cxx:781
 AliMUONCalibrationData.cxx:782
 AliMUONCalibrationData.cxx:783
 AliMUONCalibrationData.cxx:784
 AliMUONCalibrationData.cxx:785
 AliMUONCalibrationData.cxx:786
 AliMUONCalibrationData.cxx:787
 AliMUONCalibrationData.cxx:788
 AliMUONCalibrationData.cxx:789
 AliMUONCalibrationData.cxx:790
 AliMUONCalibrationData.cxx:791
 AliMUONCalibrationData.cxx:792
 AliMUONCalibrationData.cxx:793
 AliMUONCalibrationData.cxx:794
 AliMUONCalibrationData.cxx:795
 AliMUONCalibrationData.cxx:796
 AliMUONCalibrationData.cxx:797
 AliMUONCalibrationData.cxx:798
 AliMUONCalibrationData.cxx:799
 AliMUONCalibrationData.cxx:800
 AliMUONCalibrationData.cxx:801
 AliMUONCalibrationData.cxx:802
 AliMUONCalibrationData.cxx:803
 AliMUONCalibrationData.cxx:804
 AliMUONCalibrationData.cxx:805
 AliMUONCalibrationData.cxx:806
 AliMUONCalibrationData.cxx:807
 AliMUONCalibrationData.cxx:808
 AliMUONCalibrationData.cxx:809
 AliMUONCalibrationData.cxx:810
 AliMUONCalibrationData.cxx:811
 AliMUONCalibrationData.cxx:812
 AliMUONCalibrationData.cxx:813
 AliMUONCalibrationData.cxx:814
 AliMUONCalibrationData.cxx:815
 AliMUONCalibrationData.cxx:816
 AliMUONCalibrationData.cxx:817
 AliMUONCalibrationData.cxx:818
 AliMUONCalibrationData.cxx:819
 AliMUONCalibrationData.cxx:820
 AliMUONCalibrationData.cxx:821
 AliMUONCalibrationData.cxx:822
 AliMUONCalibrationData.cxx:823
 AliMUONCalibrationData.cxx:824
 AliMUONCalibrationData.cxx:825
 AliMUONCalibrationData.cxx:826
 AliMUONCalibrationData.cxx:827
 AliMUONCalibrationData.cxx:828
 AliMUONCalibrationData.cxx:829
 AliMUONCalibrationData.cxx:830
 AliMUONCalibrationData.cxx:831
 AliMUONCalibrationData.cxx:832
 AliMUONCalibrationData.cxx:833
 AliMUONCalibrationData.cxx:834
 AliMUONCalibrationData.cxx:835
 AliMUONCalibrationData.cxx:836
 AliMUONCalibrationData.cxx:837
 AliMUONCalibrationData.cxx:838
 AliMUONCalibrationData.cxx:839
 AliMUONCalibrationData.cxx:840
 AliMUONCalibrationData.cxx:841
 AliMUONCalibrationData.cxx:842
 AliMUONCalibrationData.cxx:843
 AliMUONCalibrationData.cxx:844
 AliMUONCalibrationData.cxx:845
 AliMUONCalibrationData.cxx:846
 AliMUONCalibrationData.cxx:847
 AliMUONCalibrationData.cxx:848
 AliMUONCalibrationData.cxx:849
 AliMUONCalibrationData.cxx:850
 AliMUONCalibrationData.cxx:851
 AliMUONCalibrationData.cxx:852
 AliMUONCalibrationData.cxx:853
 AliMUONCalibrationData.cxx:854
 AliMUONCalibrationData.cxx:855
 AliMUONCalibrationData.cxx:856
 AliMUONCalibrationData.cxx:857
 AliMUONCalibrationData.cxx:858
 AliMUONCalibrationData.cxx:859
 AliMUONCalibrationData.cxx:860
 AliMUONCalibrationData.cxx:861
 AliMUONCalibrationData.cxx:862
 AliMUONCalibrationData.cxx:863
 AliMUONCalibrationData.cxx:864
 AliMUONCalibrationData.cxx:865
 AliMUONCalibrationData.cxx:866
 AliMUONCalibrationData.cxx:867
 AliMUONCalibrationData.cxx:868
 AliMUONCalibrationData.cxx:869
 AliMUONCalibrationData.cxx:870
 AliMUONCalibrationData.cxx:871
 AliMUONCalibrationData.cxx:872
 AliMUONCalibrationData.cxx:873
 AliMUONCalibrationData.cxx:874
 AliMUONCalibrationData.cxx:875
 AliMUONCalibrationData.cxx:876
 AliMUONCalibrationData.cxx:877
 AliMUONCalibrationData.cxx:878
 AliMUONCalibrationData.cxx:879
 AliMUONCalibrationData.cxx:880
 AliMUONCalibrationData.cxx:881
 AliMUONCalibrationData.cxx:882
 AliMUONCalibrationData.cxx:883
 AliMUONCalibrationData.cxx:884
 AliMUONCalibrationData.cxx:885
 AliMUONCalibrationData.cxx:886
 AliMUONCalibrationData.cxx:887
 AliMUONCalibrationData.cxx:888
 AliMUONCalibrationData.cxx:889
 AliMUONCalibrationData.cxx:890
 AliMUONCalibrationData.cxx:891
 AliMUONCalibrationData.cxx:892
 AliMUONCalibrationData.cxx:893
 AliMUONCalibrationData.cxx:894
 AliMUONCalibrationData.cxx:895
 AliMUONCalibrationData.cxx:896
 AliMUONCalibrationData.cxx:897
 AliMUONCalibrationData.cxx:898
 AliMUONCalibrationData.cxx:899
 AliMUONCalibrationData.cxx:900
 AliMUONCalibrationData.cxx:901
 AliMUONCalibrationData.cxx:902
 AliMUONCalibrationData.cxx:903
 AliMUONCalibrationData.cxx:904
 AliMUONCalibrationData.cxx:905
 AliMUONCalibrationData.cxx:906
 AliMUONCalibrationData.cxx:907
 AliMUONCalibrationData.cxx:908
 AliMUONCalibrationData.cxx:909
 AliMUONCalibrationData.cxx:910
 AliMUONCalibrationData.cxx:911
 AliMUONCalibrationData.cxx:912
 AliMUONCalibrationData.cxx:913
 AliMUONCalibrationData.cxx:914
 AliMUONCalibrationData.cxx:915
 AliMUONCalibrationData.cxx:916
 AliMUONCalibrationData.cxx:917
 AliMUONCalibrationData.cxx:918
 AliMUONCalibrationData.cxx:919
 AliMUONCalibrationData.cxx:920
 AliMUONCalibrationData.cxx:921
 AliMUONCalibrationData.cxx:922
 AliMUONCalibrationData.cxx:923
 AliMUONCalibrationData.cxx:924
 AliMUONCalibrationData.cxx:925
 AliMUONCalibrationData.cxx:926
 AliMUONCalibrationData.cxx:927
 AliMUONCalibrationData.cxx:928
 AliMUONCalibrationData.cxx:929
 AliMUONCalibrationData.cxx:930
 AliMUONCalibrationData.cxx:931
 AliMUONCalibrationData.cxx:932
 AliMUONCalibrationData.cxx:933
 AliMUONCalibrationData.cxx:934
 AliMUONCalibrationData.cxx:935
 AliMUONCalibrationData.cxx:936
 AliMUONCalibrationData.cxx:937
 AliMUONCalibrationData.cxx:938
 AliMUONCalibrationData.cxx:939
 AliMUONCalibrationData.cxx:940
 AliMUONCalibrationData.cxx:941
 AliMUONCalibrationData.cxx:942
 AliMUONCalibrationData.cxx:943
 AliMUONCalibrationData.cxx:944
 AliMUONCalibrationData.cxx:945
 AliMUONCalibrationData.cxx:946
 AliMUONCalibrationData.cxx:947
 AliMUONCalibrationData.cxx:948
 AliMUONCalibrationData.cxx:949
 AliMUONCalibrationData.cxx:950
 AliMUONCalibrationData.cxx:951
 AliMUONCalibrationData.cxx:952
 AliMUONCalibrationData.cxx:953
 AliMUONCalibrationData.cxx:954
 AliMUONCalibrationData.cxx:955
 AliMUONCalibrationData.cxx:956
 AliMUONCalibrationData.cxx:957
 AliMUONCalibrationData.cxx:958
 AliMUONCalibrationData.cxx:959
 AliMUONCalibrationData.cxx:960
 AliMUONCalibrationData.cxx:961
 AliMUONCalibrationData.cxx:962
 AliMUONCalibrationData.cxx:963
 AliMUONCalibrationData.cxx:964
 AliMUONCalibrationData.cxx:965
 AliMUONCalibrationData.cxx:966
 AliMUONCalibrationData.cxx:967
 AliMUONCalibrationData.cxx:968
 AliMUONCalibrationData.cxx:969
 AliMUONCalibrationData.cxx:970
 AliMUONCalibrationData.cxx:971
 AliMUONCalibrationData.cxx:972
 AliMUONCalibrationData.cxx:973
 AliMUONCalibrationData.cxx:974
 AliMUONCalibrationData.cxx:975
 AliMUONCalibrationData.cxx:976
 AliMUONCalibrationData.cxx:977
 AliMUONCalibrationData.cxx:978
 AliMUONCalibrationData.cxx:979
 AliMUONCalibrationData.cxx:980
 AliMUONCalibrationData.cxx:981
 AliMUONCalibrationData.cxx:982
 AliMUONCalibrationData.cxx:983
 AliMUONCalibrationData.cxx:984
 AliMUONCalibrationData.cxx:985
 AliMUONCalibrationData.cxx:986
 AliMUONCalibrationData.cxx:987
 AliMUONCalibrationData.cxx:988
 AliMUONCalibrationData.cxx:989
 AliMUONCalibrationData.cxx:990
 AliMUONCalibrationData.cxx:991
 AliMUONCalibrationData.cxx:992
 AliMUONCalibrationData.cxx:993
 AliMUONCalibrationData.cxx:994
 AliMUONCalibrationData.cxx:995
 AliMUONCalibrationData.cxx:996
 AliMUONCalibrationData.cxx:997
 AliMUONCalibrationData.cxx:998
 AliMUONCalibrationData.cxx:999
 AliMUONCalibrationData.cxx:1000
 AliMUONCalibrationData.cxx:1001
 AliMUONCalibrationData.cxx:1002
 AliMUONCalibrationData.cxx:1003
 AliMUONCalibrationData.cxx:1004
 AliMUONCalibrationData.cxx:1005
 AliMUONCalibrationData.cxx:1006
 AliMUONCalibrationData.cxx:1007
 AliMUONCalibrationData.cxx:1008
 AliMUONCalibrationData.cxx:1009
 AliMUONCalibrationData.cxx:1010
 AliMUONCalibrationData.cxx:1011
 AliMUONCalibrationData.cxx:1012
 AliMUONCalibrationData.cxx:1013
 AliMUONCalibrationData.cxx:1014
 AliMUONCalibrationData.cxx:1015
 AliMUONCalibrationData.cxx:1016
 AliMUONCalibrationData.cxx:1017
 AliMUONCalibrationData.cxx:1018
 AliMUONCalibrationData.cxx:1019
 AliMUONCalibrationData.cxx:1020
 AliMUONCalibrationData.cxx:1021
 AliMUONCalibrationData.cxx:1022
 AliMUONCalibrationData.cxx:1023
 AliMUONCalibrationData.cxx:1024
 AliMUONCalibrationData.cxx:1025
 AliMUONCalibrationData.cxx:1026
 AliMUONCalibrationData.cxx:1027
 AliMUONCalibrationData.cxx:1028
 AliMUONCalibrationData.cxx:1029
 AliMUONCalibrationData.cxx:1030
 AliMUONCalibrationData.cxx:1031
 AliMUONCalibrationData.cxx:1032
 AliMUONCalibrationData.cxx:1033
 AliMUONCalibrationData.cxx:1034
 AliMUONCalibrationData.cxx:1035
 AliMUONCalibrationData.cxx:1036
 AliMUONCalibrationData.cxx:1037
 AliMUONCalibrationData.cxx:1038
 AliMUONCalibrationData.cxx:1039
 AliMUONCalibrationData.cxx:1040
 AliMUONCalibrationData.cxx:1041
 AliMUONCalibrationData.cxx:1042
 AliMUONCalibrationData.cxx:1043
 AliMUONCalibrationData.cxx:1044
 AliMUONCalibrationData.cxx:1045
 AliMUONCalibrationData.cxx:1046
 AliMUONCalibrationData.cxx:1047
 AliMUONCalibrationData.cxx:1048
 AliMUONCalibrationData.cxx:1049
 AliMUONCalibrationData.cxx:1050
 AliMUONCalibrationData.cxx:1051
 AliMUONCalibrationData.cxx:1052
 AliMUONCalibrationData.cxx:1053
 AliMUONCalibrationData.cxx:1054
 AliMUONCalibrationData.cxx:1055
 AliMUONCalibrationData.cxx:1056
 AliMUONCalibrationData.cxx:1057
 AliMUONCalibrationData.cxx:1058
 AliMUONCalibrationData.cxx:1059
 AliMUONCalibrationData.cxx:1060
 AliMUONCalibrationData.cxx:1061
 AliMUONCalibrationData.cxx:1062
 AliMUONCalibrationData.cxx:1063
 AliMUONCalibrationData.cxx:1064
 AliMUONCalibrationData.cxx:1065
 AliMUONCalibrationData.cxx:1066
 AliMUONCalibrationData.cxx:1067
 AliMUONCalibrationData.cxx:1068
 AliMUONCalibrationData.cxx:1069
 AliMUONCalibrationData.cxx:1070
 AliMUONCalibrationData.cxx:1071
 AliMUONCalibrationData.cxx:1072
 AliMUONCalibrationData.cxx:1073
 AliMUONCalibrationData.cxx:1074
 AliMUONCalibrationData.cxx:1075
 AliMUONCalibrationData.cxx:1076
 AliMUONCalibrationData.cxx:1077
 AliMUONCalibrationData.cxx:1078
 AliMUONCalibrationData.cxx:1079
 AliMUONCalibrationData.cxx:1080
 AliMUONCalibrationData.cxx:1081
 AliMUONCalibrationData.cxx:1082
 AliMUONCalibrationData.cxx:1083
 AliMUONCalibrationData.cxx:1084
 AliMUONCalibrationData.cxx:1085
 AliMUONCalibrationData.cxx:1086
 AliMUONCalibrationData.cxx:1087
 AliMUONCalibrationData.cxx:1088
 AliMUONCalibrationData.cxx:1089
 AliMUONCalibrationData.cxx:1090
 AliMUONCalibrationData.cxx:1091
 AliMUONCalibrationData.cxx:1092
 AliMUONCalibrationData.cxx:1093
 AliMUONCalibrationData.cxx:1094
 AliMUONCalibrationData.cxx:1095
 AliMUONCalibrationData.cxx:1096
 AliMUONCalibrationData.cxx:1097
 AliMUONCalibrationData.cxx:1098
 AliMUONCalibrationData.cxx:1099
 AliMUONCalibrationData.cxx:1100
 AliMUONCalibrationData.cxx:1101
 AliMUONCalibrationData.cxx:1102
 AliMUONCalibrationData.cxx:1103
 AliMUONCalibrationData.cxx:1104
 AliMUONCalibrationData.cxx:1105
 AliMUONCalibrationData.cxx:1106
 AliMUONCalibrationData.cxx:1107
 AliMUONCalibrationData.cxx:1108
 AliMUONCalibrationData.cxx:1109
 AliMUONCalibrationData.cxx:1110
 AliMUONCalibrationData.cxx:1111
 AliMUONCalibrationData.cxx:1112
 AliMUONCalibrationData.cxx:1113
 AliMUONCalibrationData.cxx:1114
 AliMUONCalibrationData.cxx:1115
 AliMUONCalibrationData.cxx:1116
 AliMUONCalibrationData.cxx:1117
 AliMUONCalibrationData.cxx:1118
 AliMUONCalibrationData.cxx:1119
 AliMUONCalibrationData.cxx:1120
 AliMUONCalibrationData.cxx:1121
 AliMUONCalibrationData.cxx:1122
 AliMUONCalibrationData.cxx:1123
 AliMUONCalibrationData.cxx:1124
 AliMUONCalibrationData.cxx:1125
 AliMUONCalibrationData.cxx:1126
 AliMUONCalibrationData.cxx:1127
 AliMUONCalibrationData.cxx:1128
 AliMUONCalibrationData.cxx:1129
 AliMUONCalibrationData.cxx:1130
 AliMUONCalibrationData.cxx:1131
 AliMUONCalibrationData.cxx:1132
 AliMUONCalibrationData.cxx:1133
 AliMUONCalibrationData.cxx:1134
 AliMUONCalibrationData.cxx:1135
 AliMUONCalibrationData.cxx:1136
 AliMUONCalibrationData.cxx:1137
 AliMUONCalibrationData.cxx:1138
 AliMUONCalibrationData.cxx:1139
 AliMUONCalibrationData.cxx:1140
 AliMUONCalibrationData.cxx:1141
 AliMUONCalibrationData.cxx:1142
 AliMUONCalibrationData.cxx:1143
 AliMUONCalibrationData.cxx:1144
 AliMUONCalibrationData.cxx:1145
 AliMUONCalibrationData.cxx:1146
 AliMUONCalibrationData.cxx:1147
 AliMUONCalibrationData.cxx:1148
 AliMUONCalibrationData.cxx:1149
 AliMUONCalibrationData.cxx:1150
 AliMUONCalibrationData.cxx:1151
 AliMUONCalibrationData.cxx:1152
 AliMUONCalibrationData.cxx:1153
 AliMUONCalibrationData.cxx:1154
 AliMUONCalibrationData.cxx:1155
 AliMUONCalibrationData.cxx:1156
 AliMUONCalibrationData.cxx:1157
 AliMUONCalibrationData.cxx:1158
 AliMUONCalibrationData.cxx:1159
 AliMUONCalibrationData.cxx:1160
 AliMUONCalibrationData.cxx:1161
 AliMUONCalibrationData.cxx:1162
 AliMUONCalibrationData.cxx:1163
 AliMUONCalibrationData.cxx:1164
 AliMUONCalibrationData.cxx:1165
 AliMUONCalibrationData.cxx:1166
 AliMUONCalibrationData.cxx:1167
 AliMUONCalibrationData.cxx:1168
 AliMUONCalibrationData.cxx:1169
 AliMUONCalibrationData.cxx:1170
 AliMUONCalibrationData.cxx:1171
 AliMUONCalibrationData.cxx:1172
 AliMUONCalibrationData.cxx:1173
 AliMUONCalibrationData.cxx:1174
 AliMUONCalibrationData.cxx:1175
 AliMUONCalibrationData.cxx:1176
 AliMUONCalibrationData.cxx:1177
 AliMUONCalibrationData.cxx:1178
 AliMUONCalibrationData.cxx:1179
 AliMUONCalibrationData.cxx:1180
 AliMUONCalibrationData.cxx:1181
 AliMUONCalibrationData.cxx:1182
 AliMUONCalibrationData.cxx:1183
 AliMUONCalibrationData.cxx:1184
 AliMUONCalibrationData.cxx:1185
 AliMUONCalibrationData.cxx:1186
 AliMUONCalibrationData.cxx:1187
 AliMUONCalibrationData.cxx:1188
 AliMUONCalibrationData.cxx:1189
 AliMUONCalibrationData.cxx:1190
 AliMUONCalibrationData.cxx:1191
 AliMUONCalibrationData.cxx:1192
 AliMUONCalibrationData.cxx:1193
 AliMUONCalibrationData.cxx:1194
 AliMUONCalibrationData.cxx:1195
 AliMUONCalibrationData.cxx:1196
 AliMUONCalibrationData.cxx:1197
 AliMUONCalibrationData.cxx:1198
 AliMUONCalibrationData.cxx:1199
 AliMUONCalibrationData.cxx:1200
 AliMUONCalibrationData.cxx:1201
 AliMUONCalibrationData.cxx:1202
 AliMUONCalibrationData.cxx:1203
 AliMUONCalibrationData.cxx:1204
 AliMUONCalibrationData.cxx:1205
 AliMUONCalibrationData.cxx:1206
 AliMUONCalibrationData.cxx:1207
 AliMUONCalibrationData.cxx:1208
 AliMUONCalibrationData.cxx:1209
 AliMUONCalibrationData.cxx:1210
 AliMUONCalibrationData.cxx:1211
 AliMUONCalibrationData.cxx:1212
 AliMUONCalibrationData.cxx:1213
 AliMUONCalibrationData.cxx:1214
 AliMUONCalibrationData.cxx:1215
 AliMUONCalibrationData.cxx:1216
 AliMUONCalibrationData.cxx:1217
 AliMUONCalibrationData.cxx:1218
 AliMUONCalibrationData.cxx:1219
 AliMUONCalibrationData.cxx:1220
 AliMUONCalibrationData.cxx:1221
 AliMUONCalibrationData.cxx:1222
 AliMUONCalibrationData.cxx:1223
 AliMUONCalibrationData.cxx:1224
 AliMUONCalibrationData.cxx:1225
 AliMUONCalibrationData.cxx:1226
 AliMUONCalibrationData.cxx:1227
 AliMUONCalibrationData.cxx:1228
 AliMUONCalibrationData.cxx:1229
 AliMUONCalibrationData.cxx:1230
 AliMUONCalibrationData.cxx:1231
 AliMUONCalibrationData.cxx:1232
 AliMUONCalibrationData.cxx:1233
 AliMUONCalibrationData.cxx:1234
 AliMUONCalibrationData.cxx:1235
 AliMUONCalibrationData.cxx:1236
 AliMUONCalibrationData.cxx:1237
 AliMUONCalibrationData.cxx:1238
 AliMUONCalibrationData.cxx:1239
 AliMUONCalibrationData.cxx:1240
 AliMUONCalibrationData.cxx:1241
 AliMUONCalibrationData.cxx:1242
 AliMUONCalibrationData.cxx:1243
 AliMUONCalibrationData.cxx:1244
 AliMUONCalibrationData.cxx:1245
 AliMUONCalibrationData.cxx:1246
 AliMUONCalibrationData.cxx:1247
 AliMUONCalibrationData.cxx:1248
 AliMUONCalibrationData.cxx:1249
 AliMUONCalibrationData.cxx:1250
 AliMUONCalibrationData.cxx:1251
 AliMUONCalibrationData.cxx:1252
 AliMUONCalibrationData.cxx:1253
 AliMUONCalibrationData.cxx:1254
 AliMUONCalibrationData.cxx:1255
 AliMUONCalibrationData.cxx:1256
 AliMUONCalibrationData.cxx:1257
 AliMUONCalibrationData.cxx:1258
 AliMUONCalibrationData.cxx:1259
 AliMUONCalibrationData.cxx:1260
 AliMUONCalibrationData.cxx:1261
 AliMUONCalibrationData.cxx:1262
 AliMUONCalibrationData.cxx:1263
 AliMUONCalibrationData.cxx:1264
 AliMUONCalibrationData.cxx:1265
 AliMUONCalibrationData.cxx:1266
 AliMUONCalibrationData.cxx:1267
 AliMUONCalibrationData.cxx:1268
 AliMUONCalibrationData.cxx:1269
 AliMUONCalibrationData.cxx:1270
 AliMUONCalibrationData.cxx:1271
 AliMUONCalibrationData.cxx:1272
 AliMUONCalibrationData.cxx:1273
 AliMUONCalibrationData.cxx:1274
 AliMUONCalibrationData.cxx:1275
 AliMUONCalibrationData.cxx:1276
 AliMUONCalibrationData.cxx:1277
 AliMUONCalibrationData.cxx:1278
 AliMUONCalibrationData.cxx:1279
 AliMUONCalibrationData.cxx:1280
 AliMUONCalibrationData.cxx:1281
 AliMUONCalibrationData.cxx:1282
 AliMUONCalibrationData.cxx:1283
 AliMUONCalibrationData.cxx:1284
 AliMUONCalibrationData.cxx:1285
 AliMUONCalibrationData.cxx:1286
 AliMUONCalibrationData.cxx:1287
 AliMUONCalibrationData.cxx:1288
 AliMUONCalibrationData.cxx:1289
 AliMUONCalibrationData.cxx:1290
 AliMUONCalibrationData.cxx:1291
 AliMUONCalibrationData.cxx:1292
 AliMUONCalibrationData.cxx:1293
 AliMUONCalibrationData.cxx:1294
 AliMUONCalibrationData.cxx:1295
 AliMUONCalibrationData.cxx:1296
 AliMUONCalibrationData.cxx:1297
 AliMUONCalibrationData.cxx:1298
 AliMUONCalibrationData.cxx:1299
 AliMUONCalibrationData.cxx:1300
 AliMUONCalibrationData.cxx:1301
 AliMUONCalibrationData.cxx:1302
 AliMUONCalibrationData.cxx:1303
 AliMUONCalibrationData.cxx:1304
 AliMUONCalibrationData.cxx:1305
 AliMUONCalibrationData.cxx:1306
 AliMUONCalibrationData.cxx:1307
 AliMUONCalibrationData.cxx:1308
 AliMUONCalibrationData.cxx:1309
 AliMUONCalibrationData.cxx:1310
 AliMUONCalibrationData.cxx:1311
 AliMUONCalibrationData.cxx:1312
 AliMUONCalibrationData.cxx:1313
 AliMUONCalibrationData.cxx:1314
 AliMUONCalibrationData.cxx:1315
 AliMUONCalibrationData.cxx:1316
 AliMUONCalibrationData.cxx:1317
 AliMUONCalibrationData.cxx:1318
 AliMUONCalibrationData.cxx:1319
 AliMUONCalibrationData.cxx:1320
 AliMUONCalibrationData.cxx:1321
 AliMUONCalibrationData.cxx:1322
 AliMUONCalibrationData.cxx:1323
 AliMUONCalibrationData.cxx:1324
 AliMUONCalibrationData.cxx:1325
 AliMUONCalibrationData.cxx:1326
 AliMUONCalibrationData.cxx:1327
 AliMUONCalibrationData.cxx:1328
 AliMUONCalibrationData.cxx:1329
 AliMUONCalibrationData.cxx:1330
 AliMUONCalibrationData.cxx:1331