Enhancements:
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Mar 2006 16:58:01 +0000 (16:58 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 2 Mar 2006 16:58:01 +0000 (16:58 +0000)
Now builds fake dead channel store too (random case not really tested though)
(Laurent)

MUON/MUONCDB.C
MUON/MUONCDB.h

index ea069fa..21ecfb8 100644 (file)
 #include "MUONCDB.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
-#include "AliMUON3DMap.h"
-#include "AliMUONV3DStore.h"
-#include "AliMUONCalibParam.h"
+#include "AliMUON2DMap.h"
+#include "AliMUONV2DStore.h"
+#include "AliMUONVCalibParam.h"
+#include "AliMUONCalibParam1I.h"
+#include "AliMUONCalibParam2F.h"
 #include "AliMpDEIterator.h"
 #include "AliMpDEManager.h"
-#include "AliMpPlaneType.h"
 #include "AliMpSegFactory.h"
 #include "AliMpStationType.h"
 #include "AliMpVSegmentation.h"
@@ -38,9 +39,8 @@
 #include "TSystem.h"
 #endif
 
-ClassImp(Triplet)
-
-static const char* CDBPath = "local://$ALICE_ROOT/MUON/CDB/Random";
+//static const char* CDBPath = "local://$ALICE_ROOT/MUON/CDB/Random";
+static const char* CDBPath = "local://$ALICE_ROOT/MUON/CDB/Default";
 
 //_____________________________________________________________________________
 AliMpSegFactory* segFactory()
@@ -50,7 +50,7 @@ AliMpSegFactory* segFactory()
 }
 
 //_____________________________________________________________________________
-AliMUONV3DStore* readCDB(const char* calibType="MUON/Calib/Pedestals")
+AliMUONV2DStore* readCDB(const char* calibType)
 {
   AliCDBManager* man = AliCDBManager::Instance();
   man->SetDefaultStorage(CDBPath);
@@ -59,25 +59,81 @@ AliMUONV3DStore* readCDB(const char* calibType="MUON/Calib/Pedestals")
 
   if (entry)
     {
-      return (AliMUONV3DStore*)entry->GetObject();
+      return (AliMUONV2DStore*)entry->GetObject();
     }
   return 0;
 }
 
 //_____________________________________________________________________________
-void plotCDB(const char* calibType="MUON/Calib/Gains")
+void checkCDB(const char* calibType)
+{
+  TString c(calibType);
+  Float_t refValue(0);
+  
+  if ( c == "MUON/Calib/DeadChannels" )
+  {
+    refValue=5;
+  }
+   
+  AliMUONV2DStore* store = readCDB(calibType);
+  if (!store) return;
+  
+  TIter next(manuList());
+  AliMpIntPair* p;
+  
+  while ( ( p = (AliMpIntPair*)next() ) )
+  {
+    Int_t detElemId = p->GetFirst();
+    Int_t manuId = p->GetSecond();
+    
+    AliMUONVCalibParam* value = 
+      dynamic_cast<AliMUONVCalibParam*>(store->Get(detElemId,manuId));
+    
+    if (value)
+    {
+      for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
+      {
+        Float_t testValue = value->ValueAsFloat(manuChannel,0);
+        if ( testValue && testValue != refValue )
+        {
+          cout << "Got a strange value for DE=" << detElemId << " manuId="
+          << manuId << " manuChannel=" << manuChannel << " was expecting "
+          << refValue << " and I got " << testValue << endl;
+        }
+      }
+    }
+    else
+    {
+      cout << "Got a null value for DE=" << detElemId << " manuId="
+      << manuId << endl;
+    }
+  }
+  
+  delete store;
+}
+
+
+//_____________________________________________________________________________
+void plotCDB(const char* calibType)
 {
   TString c(calibType);
   
   TH1* h = 0;
+  TH1* h2 = 0;
   
   if ( c == "MUON/Calib/Gains" )
   {
-    h = new TH1F("gains","gains",100,0,1.5);
+    h = new TH1F("gains_mean","mean gain",100,0,1.5);
+    h2 = new TH1F("saturation","adc saturation",4096,-0.5,4095.5);
   }
   else if ( c == "MUON/Calib/Pedestals" )
   {
-    h = new TH1F("pedestals","pedestals",4096,-0.5,4095.5);
+    h = new TH1F("pedestals_mean","pedestals_mean",4096,-0.5,4095.5);
+    h2 = new TH1F("pedestals_sigma","pedestals_sigma",100,0,20);
+  }
+  else if ( c == "MUON/Calib/DeadChannels" )
+  {
+    h = new TH1F("dead_channels","dead channels per DE",1500,-0.5,1499.5);
   }
   else
   {
@@ -85,102 +141,162 @@ void plotCDB(const char* calibType="MUON/Calib/Gains")
     return;
   }
   
-  AliMUONV3DStore* store = readCDB(calibType);
+  AliMUONV2DStore* store = readCDB(calibType);
   if (!store) return;
 
-  TIter next(padList());
-  Triplet* t;
+  TIter next(manuList());
+  AliMpIntPair* p;
+  Int_t n(0);
+  Int_t ndead(0);
+  Int_t nPerStation[7];
+  
+  for ( Int_t i = 0; i < 7; ++i ) nPerStation[i]=0;
   
-  while ( ( t = (Triplet*)next() ) )
+  while ( ( p = (AliMpIntPair*)next() ) )
   {
-    Int_t detElemId = t->DetElemId();
-    Int_t manuId = t->ManuId();
-    Int_t manuChannel = t->ManuChannel();
+    Int_t detElemId = p->GetFirst();
+    Int_t manuId = p->GetSecond();
+    
+    Int_t station = detElemId/100 - 1;
+    
+    AliMUONVCalibParam* value = 
+    dynamic_cast<AliMUONVCalibParam*>(store->Get(detElemId,manuId));
     
-    AliMUONCalibParam* value = 
-    dynamic_cast<AliMUONCalibParam*>(store->Get(detElemId,manuId,manuChannel));
     if (value)
     {
-      h->Fill(value->Mean());
+      for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
+      {
+        ++n;
+        ++nPerStation[station];
+        if (h2)
+        {
+          h->Fill(value->ValueAsFloat(manuChannel,0));
+          h2->Fill(value->ValueAsFloat(manuChannel,1));
+        }
+        else
+        {
+          if( value->ValueAsInt(manuChannel) )
+          {
+            h->Fill(detElemId);
+            ++ndead;
+          }
+        }
+      }
     }
     else
     {
       cout << "Got a null value for DE=" << detElemId << " manuId="
-      << manuId << " manuChannel=" << manuChannel << endl;
+        << manuId << endl;
     }
   }
   
+  cout << "Number of channels = " << n << endl;
+  for ( Int_t i = 0; i < 7; ++i )
+  {
+    cout << "Station " << (i+1) << " " << nPerStation[i] << endl;
+  }
+  
+  if (n && c == "MUON/Calib/DeadChannels")
+  {
+    cout << "Number of dead channels=" << ndead << endl;
+  }
   delete store;
 }
 
 //_____________________________________________________________________________
-void testReadStore(const AliMUONV3DStore& store, Int_t n)
+void testReadStore(const AliMUONV2DStore& store, Int_t n)
 {
-  TIter next(padList());
-  Triplet* t;
+  TIter next(manuList());
+  AliMpIntPair* p;
   
-  while ( ( t = (Triplet*)next() ) )
+  while ( ( p = (AliMpIntPair*)next() ) )
   {
     for ( Int_t i = 0; i < n; ++i )
     {
-      store.Get(t->DetElemId(),t->ManuId(),t->ManuChannel());
+      store.Get(p->GetFirst(),p->GetSecond());
     }
   }
 } 
 
 //_____________________________________________________________________________
-Int_t makeStores(AliMUONV3DStore& pedestalStore,
-                 AliMUONV3DStore& gainStore,
+Int_t makeStores(AliMUONV2DStore& pedestalStore,
+                 AliMUONV2DStore& gainStore,
+                 AliMUONV2DStore& deadStore,
                  Bool_t defaultValues)
 {  
-  TIter next(padList());
+  TIter next(manuList());
   
-  Triplet* t;
+  AliMpIntPair* p;
   
   Int_t ngenerated(0);
   
   Bool_t replace = kFALSE;
   
-  while ( ( t = (Triplet*)next() ) )
+  const Int_t nChannels(64);
+  
+  while ( ( p = (AliMpIntPair*)next() ) )
   {
-    Float_t meanPedestal;
-    Float_t sigmaPedestal;
-    Float_t meanGain;
-    if ( defaultValues ) 
-    {
-      meanPedestal = 0.0;
-      sigmaPedestal = 1.0;
-      meanGain = 1.0;
-    }
-    else
+    AliMUONVCalibParam* ped = new AliMUONCalibParam2F(nChannels);
+    AliMUONVCalibParam* gain = new AliMUONCalibParam2F(nChannels);
+    AliMUONVCalibParam* dead = new AliMUONCalibParam1I(nChannels);
+
+    for ( Int_t manuChannel = 0; manuChannel < nChannels; ++manuChannel )
     {
-      meanPedestal = -1;
-      while ( meanPedestal < 0 )
+      Float_t meanPedestal;
+      Float_t sigmaPedestal;
+      Float_t meanGain;
+      Float_t saturation(3000);
+    
+      if ( defaultValues ) 
       {
-        meanPedestal = gRandom->Gaus(150,10);
+        meanPedestal = 0.0;
+        sigmaPedestal = 1.0;
+        meanGain = 1.0;
       }
-      sigmaPedestal = -1;
-      while ( sigmaPedestal < 0 )
+      else
       {
-        sigmaPedestal = gRandom->Gaus(1,0.2);
+        meanPedestal = -1;
+        while ( meanPedestal < 0 )
+        {
+          meanPedestal = gRandom->Gaus(150,10);
+        }
+        sigmaPedestal = -1;
+        while ( sigmaPedestal < 0 )
+        {
+          sigmaPedestal = gRandom->Gaus(1,0.2);
+        }
+        meanGain = -1;
+        while ( meanGain < 0 )
+        {
+          meanGain = gRandom->Gaus(1,0.05);
+        }
       }
-      meanGain = -1;
-      while ( meanGain < 0 )
+      ped->SetValueAsFloat(manuChannel,0,meanPedestal);
+      ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
+      gain->SetValueAsFloat(manuChannel,0,meanGain);
+      gain->SetValueAsFloat(manuChannel,1,saturation);
+      
+      if (!defaultValues)
       {
-        meanGain = gRandom->Gaus(1,0.05);
+        // probability that this channel is dead ~ 1%
+        if ( gRandom->Uniform(100.0) < 1.0 ) 
+        {
+          Int_t reason = 5; // that value could be used to distinguish
+          // why the channel is dead or how it was flagged bad (online,
+          // offline, by chance...). 5 is of course a fake number.
+          dead->SetValueAsInt(manuChannel,0,reason);
+        }
       }
     }
-    Int_t detElemId = t->DetElemId();
-    Int_t manuId = t->ManuId();
-    Int_t manuChannel = t->ManuChannel();
-    Bool_t ok1 = pedestalStore.Set(detElemId,manuId,manuChannel,
-                                   new AliMUONCalibParam(meanPedestal,sigmaPedestal),replace);
-    Bool_t ok2 = gainStore.Set(detElemId,manuId,manuChannel,
-                               new AliMUONCalibParam(meanGain,0),replace);
-    if (!ok1 || !ok2)
+    Int_t detElemId = p->GetFirst();
+    Int_t manuId = p->GetSecond();
+    Bool_t ok1 = pedestalStore.Set(detElemId,manuId,ped,replace);
+    Bool_t ok2 = gainStore.Set(detElemId,manuId,gain,replace);
+    Bool_t ok3 = deadStore.Set(detElemId,manuId,dead,replace);
+    if (!ok1 || !ok2 || !ok3)
     {
       cout << "Could not set DetElemId=" << detElemId << " manuId="
-      << manuId << " manuChannel=" << manuChannel << endl;
+        << manuId << endl;
     }
     else
     {
@@ -192,23 +308,23 @@ Int_t makeStores(AliMUONV3DStore& pedestalStore,
 }
 
 //_____________________________________________________________________________
-TList* padList(Bool_t reset)
+TList* manuList(Bool_t reset)
 {
-  static TList* fgPadList = new TList;
+  static TList* fgmanuList = new TList;
   
   if (reset) 
   {
-    fgPadList->Delete();
-    return fgPadList;
+    fgmanuList->Delete();
+    return fgmanuList;
   }
   
-  if (!fgPadList->IsEmpty()) return fgPadList;
+  if (!fgmanuList->IsEmpty()) return fgmanuList;
   
   TStopwatch timer;
   
-  cout << "Generating pad list. Please wait" << endl;
+  cout << "Generating manu list. Please wait" << endl;
   
-  fgPadList->SetOwner(kTRUE);
+  fgmanuList->SetOwner(kTRUE);
   
   timer.Start();
   
@@ -225,75 +341,68 @@ TList* padList(Bool_t reset)
       for ( Int_t cath = 0; cath <=1 ; ++cath )
       {
         AliMpVSegmentation* seg = segFactory()->CreateMpSegmentation(detElemId,cath);
-        AliMpPlaneType planeType = AliMpDEManager::GetPlaneType(detElemId,cath);
         
-        for ( Int_t ix = 0; ix <= seg->MaxPadIndexX(); ++ix )
-        { 
-          for ( Int_t iy = 0; iy <= seg->MaxPadIndexY(); ++iy )
-          {
-            AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kFALSE);
-            if ( pad.IsValid() )
-            {
-              Int_t manuId = pad.GetLocation().GetFirst();
-              if ( planeType == kNonBendingPlane )
-              {
-                manuId |= (1<<11);
-              }
-              Int_t manuChannel = pad.GetLocation().GetSecond();
-              fgPadList->Add(new Triplet(detElemId,manuId,manuChannel));
-            }
-          }
-        }
+        TArrayI manus;
+        
+        seg->GetAllElectronicCardIDs(manus);
+        
+        for ( Int_t im = 0; im < manus.GetSize(); ++im )
+        {
+          fgmanuList->Add(new AliMpIntPair(detElemId,manus[im]));
+        }        
       }
     }
     it.Next();
   }
   
-  cout << "Time to make the pad list = ";
+  cout << "Time to make the manu list = ";
   timer.Print();
   
-  return fgPadList;
+  return fgmanuList;
 }
 
 //_____________________________________________________________________________
-void testMakeStores(Int_t readLoop=10)
+void testMakeStores(Int_t readLoop)
 {
-  padList();
+  manuList();
   
-  AliMUONV3DStore* pedestalStore = new AliMUON3DMap;
-  AliMUONV3DStore* gainStore = new AliMUON3DMap;
+  AliMUONV2DStore* pedestalStore = new AliMUON2DMap;
+  AliMUONV2DStore* gainStore = new AliMUON2DMap;
+  AliMUONV2DStore* deadStore = new AliMUON2DMap;
   
   TStopwatch timer;
   
   cout << "Creating" << endl;
   
   timer.Start(kTRUE);
-  makeStores(*pedestalStore,*gainStore,true);
+  makeStores(*pedestalStore,*gainStore,*deadStore,true);
   timer.Print();
   
   cout << "Reading..." << endl;
   timer.Start(kTRUE);
   testReadStore(*pedestalStore,readLoop);
   testReadStore(*gainStore,readLoop);
+  testReadStore(*deadStore,readLoop);
   cout << timer.CpuTime()/readLoop << " CPUs (mean of " << readLoop 
     <<" samples." << endl;
   
   delete pedestalStore;
   delete gainStore;
+  delete deadStore;
 }
 
 //_____________________________________________________________________________
-void generateCalibrations(const char* cdbpath = CDBPath,
-                          Bool_t defaultValues = kFALSE)
+void generateCalibrations(const char* cdbpath, Bool_t defaultValues)
 {
   //
   //
   //
 
-  AliMUONV3DStore* pedestalStore = new AliMUON3DMap;
-  AliMUONV3DStore* gainStore = new AliMUON3DMap;
-  makeStores(*pedestalStore,*gainStore,defaultValues);
+  AliMUONV2DStore* pedestalStore = new AliMUON2DMap;
+  AliMUONV2DStore* gainStore = new AliMUON2DMap;
+  AliMUONV2DStore* deadStore = new AliMUON2DMap; 
+  
+  makeStores(*pedestalStore,*gainStore,*deadStore,defaultValues);
   
   Int_t ever = 99999999;
   
@@ -319,6 +428,11 @@ void generateCalibrations(const char* cdbpath = CDBPath,
   
   man->Put(gainStore,id,(AliCDBMetaData*)md.Clone());
   
+  id.SetPath("MUON/Calib/DeadChannels");
+  
+  man->Put(deadStore,id,(AliCDBMetaData*)md.Clone());
+  
+  delete deadStore;
   delete pedestalStore;
   delete gainStore;
 }
index bd16781..93c17ce 100644 (file)
@@ -6,28 +6,19 @@
 
 /// By Laurent Aphecetche
 
+#include "Rtypes.h"
+
 class TList;
+class AliMUONV2DStore;
+
+void generateCalibrations(const char* cdbpath, Bool_t defaultValues = kTRUE);
+
+TList* manuList(Bool_t reset=kFALSE);
+
+void plotCDB(const char* calibType="MUON/Calib/Pedestals");
 
-TList* padList(Bool_t reset=kFALSE);
-
-class Triplet : public TObject
-{
-public:
-  Triplet(Int_t detElemId=0, Int_t manuId=0, Int_t manuChannel=0)
-  : TObject(),fDetElemId(detElemId),fManuId(manuId),fManuChannel(manuChannel)
-{}
-  virtual ~Triplet() {}
-  
-  Int_t DetElemId() const { return fDetElemId; }
-  Int_t ManuId() const { return fManuId; }
-  Int_t ManuChannel() const { return fManuChannel; }
-  
-private:
-    Int_t fDetElemId;
-  Int_t fManuId;
-  Int_t fManuChannel;
-  ClassDef(Triplet,1)
-};
+AliMUONV2DStore* readCDB(const char* calibType="MUON/Calib/Pedestals");
 
+void testMakeStores(Int_t readLoop=10);
 
 #endif