#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"
#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()
}
//_____________________________________________________________________________
-AliMUONV3DStore* readCDB(const char* calibType="MUON/Calib/Pedestals")
+AliMUONV2DStore* readCDB(const char* calibType)
{
AliCDBManager* man = AliCDBManager::Instance();
man->SetDefaultStorage(CDBPath);
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
{
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
{
}
//_____________________________________________________________________________
-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();
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;
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;
}