**************************************************************************/
/* $Id$ */
-
+
//-----------------------------------------------------------------------------
-/// \class AliMUONCDB
+/// \namespace AliMUONCDB
+///
+/// Helper functions to experience the OCDB
///
-/// Helper class to experience the OCDB
-/// It allows to generate dummy (but complete) containers for all the
+/// They allow to read magnetic field, mapping and recoParam from OCDB
+///
+/// And also to generate dummy (but complete) containers for all the
/// calibration data types we have for tracker and trigger, and to write
/// them into OCDB.
///
-/// For more information, please see READMECDB
+/// For more information, please see READMEcalib
///
-// \author Laurent Aphecetche
+/// \author Laurent Aphecetche
//-----------------------------------------------------------------------------
#include "AliMUONCDB.h"
-#include "AliCDBEntry.h"
-#include "AliCDBManager.h"
-#include "AliDCSValue.h"
-#include "AliLog.h"
#include "AliMUON1DArray.h"
#include "AliMUON1DMap.h"
#include "AliMUON2DMap.h"
#include "AliMUON2DStoreValidator.h"
+#include "AliMUONCalibParamND.h"
#include "AliMUONCalibParamNF.h"
#include "AliMUONCalibParamNI.h"
+#include "AliMUONCalibrationData.h"
#include "AliMUONConstants.h"
-#include "AliMUONHVNamer.h"
+#include "AliMUONGlobalCrateConfig.h"
+#include "AliMUONLogger.h"
+#include "AliMUONPadStatusMaker.h"
+#include "AliMUONPadStatusMapMaker.h"
+#include "AliMUONRecoParam.h"
+#include "AliMUONRegionalTriggerConfig.h"
+#include "AliMUONRejectList.h"
+#include "AliMUONTrackerData.h"
+#include "AliMUONTrackerIO.h"
#include "AliMUONTriggerEfficiencyCells.h"
#include "AliMUONTriggerLut.h"
-#include "AliMUONVStore.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVCalibParam.h"
+#include "AliMUONVStore.h"
+
+#include "AliMpCDB.h"
#include "AliMpConstants.h"
+#include "AliMpDEStore.h"
#include "AliMpDDLStore.h"
-#include "AliMpDEIterator.h"
+#include "AliMpManuStore.h"
#include "AliMpDEManager.h"
#include "AliMpDetElement.h"
-#include "AliMpManuList.h"
+#include "AliMpFiles.h"
+#include "AliMpDCSNamer.h"
+#include "AliMpManuIterator.h"
#include "AliMpSegmentation.h"
#include "AliMpStationType.h"
#include "AliMpVSegmentation.h"
+
+#include "AliCodeTimer.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliGRPManager.h"
+#include "AliDCSValue.h"
+#include "AliLog.h"
+#include "AliMpBusPatch.h"
+
#include <Riostream.h>
#include <TArrayI.h>
#include <TClass.h>
+#include <TFile.h>
#include <TH1F.h>
#include <TList.h>
#include <TMap.h>
#include <TStopwatch.h>
#include <TSystem.h>
#include <TMath.h>
+#include <TGeoGlobalMagField.h>
+#include <TClonesArray.h>
+#include <sstream>
+#include <set>
-/// \cond CLASSIMP
-ClassImp(AliMUONCDB)
-/// \endcond
+using std::endl;
+using std::cout;
+using std::cerr;
+using std::ostringstream;
+using std::ifstream;
namespace
{
-//_____________________________________________________________________________
+ //_____________________________________________________________________________
+AliMUONVStore* Create2DMap()
+{
+ return new AliMUON2DMap(true);
+}
+
+ //_____________________________________________________________________________
void getBoundaries(const AliMUONVStore& store, Int_t dim,
Float_t* xmin, Float_t* xmax)
{
const AliMpVSegmentation* seg =
AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
+ if (!seg) continue;
+
for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
{
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
+ AliMpPad pad = seg->PadByLocation(manuId,manuChannel,kFALSE);
if (!pad.IsValid()) continue;
for ( Int_t i = 0; i < dim; ++i )
}
//_____________________________________________________________________________
-AliMUONCDB::AliMUONCDB(const char* cdbpath)
-: TObject(),
- fCDBPath(cdbpath),
- fManuList(0x0),
- fMaxNofChannelsToGenerate(-1)
+Bool_t AliMUONCDB::CheckOCDB(Bool_t pathOnly)
+{
+ /// Check that OCDB path and run number are properly set
+
+ AliCDBManager* man = AliCDBManager::Instance();
+
+ // first OCDB path
+ if (!man->IsDefaultStorageSet()) {
+ AliErrorGeneral("AliMUONCDB", "OCDB path must be properly set");
+ return kFALSE;
+ }
+
+ // then run number if required
+ if (pathOnly) return kTRUE;
+ if (man->GetRun() < 0) {
+ AliErrorGeneral("AliMUONCDB", "Run number must be properly set");
+ return kFALSE;
+ }
+
+ return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliMUONCDB::CheckMapping(Bool_t segmentationOnly)
{
- /// ctor
+ /// Check that the mapping has been loaded
+
+ // first the segmentation
+ if (!AliMpSegmentation::Instance(false)) {
+ AliErrorGeneral("AliMUONCDB", "Mapping segmentation must be loaded first");
+ return kFALSE;
+ }
+
+ // then the others if required
+ if (segmentationOnly) return kTRUE;
+ if (!AliMpDDLStore::Instance(false) || !AliMpDEStore::Instance(false) || !AliMpManuStore::Instance(false)) {
+ AliErrorGeneral("AliMUONCDB", "Full mapping must be loaded first");
+ return kFALSE;
+ }
+
+ return kTRUE;
+
}
//_____________________________________________________________________________
-AliMUONCDB::~AliMUONCDB()
+Bool_t AliMUONCDB::LoadField()
{
- /// dtor
- delete fManuList;
+ /// Load magnetic field (existing field will be deleted).
+ /// OCDB path and run number are supposed to be set.
+
+ AliInfoGeneral("AliMUONCDB","Loading field map from GRP...");
+
+ if (!AliMUONCDB::CheckOCDB()) return kFALSE;
+
+ AliGRPManager grpMan;
+
+ // make sure the old field is deleted even if it is locked
+ if(TGeoGlobalMagField::Instance()->IsLocked()) delete TGeoGlobalMagField::Instance();
+
+ if (!grpMan.ReadGRPEntry() || !grpMan.SetMagField()) {
+ AliErrorGeneral("AliMUONCDB", "failed to load magnetic field from OCDB");
+ return kFALSE;
+ }
+
+ return kTRUE;
+
}
//_____________________________________________________________________________
-TList*
-AliMUONCDB::ManuList()
+Bool_t AliMUONCDB::LoadMapping(Bool_t segmentationOnly)
{
- /// return (and create if necessary) the list of (de,manu) pairs
- if (!fManuList)
- {
- AliInfo("Generating ManuList...");
- fManuList = AliMpManuList::ManuList();
- AliInfo("Manu List generated.");
+ /// Load mapping (existing mapping will be unloaded).
+ /// OCDB path and run number are supposed to be set.
+
+ AliInfoGeneral("AliMUONCDB", "Loading mapping from OCDB...");
+
+ if (!AliMUONCDB::CheckOCDB()) return kFALSE;
+
+ // in case it has already been set
+ AliMpCDB::UnloadAll();
+
+ if (segmentationOnly) {
+
+ if (!AliMpCDB::LoadMpSegmentation(kTRUE)){
+ AliErrorGeneral("AliMUONCDB", "failed to load segmentation from OCDB");
+ return kFALSE;
+ }
+
+ } else {
+
+ if (!AliMpCDB::LoadAll(kTRUE)) {
+ AliErrorGeneral("AliMUONCDB", "failed to load mapping from OCDB");
+ return kFALSE;
+ }
+
+ }
+
+ return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+AliMUONRecoParam* AliMUONCDB::LoadRecoParam()
+{
+ /// Load and return reconstruction parameters.
+ /// OCDB path is supposed to be set.
+
+ AliInfoGeneral("AliMUONCDB", "Loading RecoParam from OCDB...");
+
+ if (!AliMUONCDB::CheckOCDB()) return 0x0;
+
+ AliMUONRecoParam* recoParam = 0x0;
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam");
+
+ if(entry) {
+
+ // load recoParam according OCDB content (single or array)
+ if (!(recoParam = dynamic_cast<AliMUONRecoParam*>(entry->GetObject()))) {
+
+ TObjArray* recoParamArray = static_cast<TObjArray*>(entry->GetObject());
+// recoParamArray->SetOwner(kTRUE); // FIXME: this should be done, but is causing a problem at the end of the reco... investigate why...
+
+ for(Int_t i = 0; i < recoParamArray->GetEntriesFast(); i++) {
+ recoParam = static_cast<AliMUONRecoParam*>(recoParamArray->UncheckedAt(i));
+ if (recoParam->IsDefault()) break;
+ recoParam = 0x0;
+ }
+
+ }
+
+ }
+
+ if (!recoParam) AliErrorGeneral("AliMUONCDB", "failed to load RecoParam from OCDB");
+
+ return recoParam;
+
+}
+
+//_____________________________________________________________________________
+TClonesArray* AliMUONCDB::LoadAlignmentData()
+{
+ /// Load and return the array of alignment objects.
+
+ AliInfoGeneral("AliMUONCDB", "Loading Alignemnt from OCDB...");
+
+ if (!AliMUONCDB::CheckOCDB()) return 0x0;
+
+ TClonesArray* alignmentArray = 0x0;
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Align/Data");
+
+ if (entry) {
+ // load alignement array
+ alignmentArray = dynamic_cast<TClonesArray*>(entry->GetObject());
}
- return fManuList;
+
+ if (!alignmentArray) {
+ AliErrorGeneral("AliMUONCDB", "failed to load Alignemnt from OCDB");
+ }
+
+ return alignmentArray;
}
//_____________________________________________________________________________
if ( !sopt.Contains("ABS") && !sopt.Contains("REL") && !sopt.Contains("PERCENT") )
{
- AliErrorClass(Form("opt %s not supported. Only ABS, REL, PERCENT are",opt));
+ AliErrorGeneral("AliMUONCDB", Form("opt %s not supported. Only ABS, REL, PERCENT are",opt));
return 0x0;
}
}
//_____________________________________________________________________________
-void
+TH1**
AliMUONCDB::Plot(const AliMUONVStore& store, const char* name, Int_t nbins)
{
/// Make histograms of each dimension of the AliMUONVCalibParam
/// contained inside store.
/// It produces histograms named name_0, name_1, etc...
+ if (!AliMUONCDB::CheckMapping(kTRUE)) return 0x0;
+
TIter next(store.CreateIterator());
AliMUONVCalibParam* param;
Int_t n(0);
{
h[i] = new TH1F(Form("%s_%d",name,i),Form("%s_%d",name,i),
nbins,xmin[i],xmax[i]);
- AliInfo(Form("Created histogram %s",h[i]->GetName()));
+ AliInfoGeneral("AliMUONCDB", Form("Created histogram %s",h[i]->GetName()));
}
+ delete [] xmin;
+ delete [] xmax;
}
Int_t detElemId = param->ID0();
const AliMpVSegmentation* seg =
AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
+ if (!seg) continue;
+
for ( Int_t manuChannel = 0; manuChannel < param->Size(); ++manuChannel )
{
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
+ AliMpPad pad = seg->PadByLocation(manuId,manuChannel,kFALSE);
if (!pad.IsValid()) continue;
++n;
for ( Int_t i = 0; i < kNStations; ++i )
{
- AliInfo(Form("Station %d %d ",(i+1),nPerStation[i]));
+ AliInfoGeneral("AliMUONCDB", Form("Station %d %d ",(i+1),nPerStation[i]));
}
- AliInfo(Form("Number of channels = %d",n));
+ AliInfoGeneral("AliMUONCDB", Form("Number of channels = %d",n));
delete[] nPerStation;
+
+ return h;
}
//_____________________________________________________________________________
{
/// Create a HV store
- AliMUONHVNamer hvNamer;
+ if (!AliMUONCDB::CheckMapping()) return 0;
+
+ AliMpDCSNamer hvNamer("TRACKER");
TObjArray* aliases = hvNamer.GenerateAliases();
delete aliases;
- AliInfo(Form("%d HV channels and %d switches",nChannels,nSwitch));
+ AliInfoGeneral("AliMUONCDB", Form("%d HV channels and %d switches",nChannels,nSwitch));
return nChannels+nSwitch;
}
+//_____________________________________________________________________________
+Int_t
+AliMUONCDB::MakeTriggerDCSStore(TMap& aliasMap, Bool_t defaultValues)
+{
+ /// Create a Trigger HV and Currents store
+
+ if (!AliMUONCDB::CheckMapping()) return 0;
+
+ AliMpDCSNamer triggerDCSNamer("TRIGGER");
+
+ TObjArray* aliases = triggerDCSNamer.GenerateAliases();
+
+ Int_t nChannels[2] = {0, 0};
+
+ for ( Int_t i = 0; i < aliases->GetEntries(); ++i )
+ {
+ TObjString* alias = static_cast<TObjString*>(aliases->At(i));
+ TString& aliasName = alias->String();
+
+ TObjArray* valueSet = new TObjArray;
+ valueSet->SetOwner(kTRUE);
+
+ Int_t measureType = triggerDCSNamer.DCSvariableFromDCSAlias(aliasName.Data());
+ if ( measureType < 0 ) {
+ AliErrorGeneralStream("AliMUONCDB")
+ << "Failed to get DCS variable from an alias (trigger): "
+ << aliasName.Data() << endl;
+ return 0;
+ }
+
+ for ( UInt_t timeStamp = 0; timeStamp < 60*15; timeStamp += 120 )
+ {
+ Float_t value =
+ (measureType == AliMpDCSNamer::kDCSI) ? 2. : 8000.;
+ if (!defaultValues) {
+ switch (measureType){
+ case AliMpDCSNamer::kDCSI:
+ value = GetRandom(2.,0.4,true);
+ break;
+ case AliMpDCSNamer::kDCSHV:
+ value = GetRandom(8000.,16.,true);
+ break;
+ }
+ }
+ AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
+ valueSet->Add(dcsValue);
+ }
+ aliasMap.Add(new TObjString(*alias),valueSet);
+ ++nChannels[measureType];
+ }
+
+ delete aliases;
+
+ AliInfoGeneral("AliMUONCDB", Form("Trigger channels I -> %i HV -> %i",nChannels[0], nChannels[1]));
+
+ return nChannels[0] + nChannels[1];
+}
+
//_____________________________________________________________________________
Int_t
AliMUONCDB::MakePedestalStore(AliMUONVStore& pedestalStore, Bool_t defaultValues)
/// Create a pedestal store. if defaultValues=true, ped.mean=ped.sigma=1,
/// otherwise mean and sigma are from a gaussian (with parameters
/// defined below by the kPedestal* constants)
+
+ AliCodeTimerAutoGeneral("",0);
- TIter next(ManuList());
-
- AliMpIntPair* p;
+ if (!AliMUONCDB::CheckMapping()) return 0;
Int_t nchannels(0);
Int_t nmanus(0);
const Int_t kChannels(AliMpConstants::ManuNofChannels());
- const Float_t kPedestalMeanMean(200);
- const Float_t kPedestalMeanSigma(10);
- const Float_t kPedestalSigmaMean(1.0);
- const Float_t kPedestalSigmaSigma(0.2);
- while ( ( p = (AliMpIntPair*)next() ) )
+ // bending
+ const Float_t kPedestalMeanMeanB(200.);
+ const Float_t kPedestalMeanSigmaB(10.);
+ const Float_t kPedestalSigmaMeanB(1.);
+ const Float_t kPedestalSigmaSigmaB(0.2);
+
+ // non bending
+ const Float_t kPedestalMeanMeanNB(200.);
+ const Float_t kPedestalMeanSigmaNB(10.);
+ const Float_t kPedestalSigmaMeanNB(1.);
+ const Float_t kPedestalSigmaSigmaNB(0.2);
+
+ const Float_t kFractionOfDeadManu(0.); // within [0.,1.]
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
{
+ // skip a given fraction of manus
+ if (kFractionOfDeadManu > 0. && gRandom->Uniform() < kFractionOfDeadManu) continue;
+
++nmanus;
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
AliMUONVCalibParam* ped =
new AliMUONCalibParamNF(2,kChannels,detElemId,manuId,AliMUONVCalibParam::InvalidFloatValue());
-
- const AliMpVSegmentation* seg =
- AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
+
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
for ( Int_t manuChannel = 0; manuChannel < kChannels; ++manuChannel )
{
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
- if (!pad.IsValid()) continue;
+ if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
++nchannels;
{
Bool_t positive(kTRUE);
meanPedestal = 0.0;
- while ( meanPedestal == 0.0 ) // avoid strict zero
- {
- meanPedestal = GetRandom(kPedestalMeanMean,kPedestalMeanSigma,positive);
- }
- sigmaPedestal = GetRandom(kPedestalSigmaMean,kPedestalSigmaSigma,positive);
+
+ if ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) ) { // manu in non bending plane
+
+ while ( meanPedestal == 0.0 ) // avoid strict zero
+ {
+ meanPedestal = GetRandom(kPedestalMeanMeanNB,kPedestalMeanSigmaNB,positive);
+ }
+ sigmaPedestal = GetRandom(kPedestalSigmaMeanNB,kPedestalSigmaSigmaNB,positive);
+
+ } else { // manu in bending plane
+
+ while ( meanPedestal == 0.0 ) // avoid strict zero
+ {
+ meanPedestal = GetRandom(kPedestalMeanMeanB,kPedestalMeanSigmaB,positive);
+ }
+ sigmaPedestal = GetRandom(kPedestalSigmaMeanB,kPedestalSigmaSigmaB,positive);
+
+ }
+
}
+
ped->SetValueAsFloat(manuChannel,0,meanPedestal);
ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
Bool_t ok = pedestalStore.Add(ped);
if (!ok)
{
- AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
+ AliErrorGeneral("AliMUONCDB", Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
}
- if ( fMaxNofChannelsToGenerate > 0 && nchannels >= fMaxNofChannelsToGenerate ) break;
}
- AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
+ AliInfoGeneral("AliMUONCDB", Form("%d Manus and %d channels.",nmanus,nchannels));
return nchannels;
+}
+
+//_____________________________________________________________________________
+AliMUONRejectList*
+AliMUONCDB::MakeRejectListStore(Bool_t defaultValues)
+{
+ /// Create a reject list
+
+ AliCodeTimerAutoGeneral("",0);
+
+ AliMUONRejectList* rl = new AliMUONRejectList;
+
+ if (!defaultValues)
+ {
+ rl->SetDetectionElementProbability(510);
+ rl->SetDetectionElementProbability(508);
+ return rl;
+ }
+
+ return rl;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONCDB::MakeOccupancyMapStore(AliMUONVStore& occupancyMapStore, Bool_t defaultValues)
+{
+ /// Create an occupancy map.
+
+ AliCodeTimerAutoGeneral("",0);
+
+ if (!AliMUONCDB::CheckMapping()) return 0;
+
+ Int_t nmanus(0);
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
+ Int_t nevents(1000);
+
+ while ( it.Next(detElemId,manuId) )
+ {
+ ++nmanus;
+
+ AliMUONVCalibParam* occupancy = new AliMUONCalibParamND(5,1,detElemId,manuId,0);
+
+ Double_t occ = 0.0;
+
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+
+ Int_t numberOfChannelsInManu = de->NofChannelsInManu(manuId);
+
+ if (!defaultValues) occ = gRandom->Rndm(1);
+
+ Double_t sumn = occ*nevents;
+
+ occupancy->SetValueAsFloat(0,0,sumn);
+ occupancy->SetValueAsFloat(0,1,sumn);
+ occupancy->SetValueAsFloat(0,2,sumn);
+ occupancy->SetValueAsInt(0,3,numberOfChannelsInManu);
+ occupancy->SetValueAsInt(0,4,nevents);
+
+ Bool_t ok = occupancyMapStore.Add(occupancy);
+ if (!ok)
+ {
+ AliErrorGeneral("AliMUONCDB", Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
+ }
+ }
+
+ return nmanus;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONCDB::MakeCapacitanceStore(AliMUONVStore& capaStore, const char* file)
+{
+ /// Read the capacitance values from file and append them to the capaStore
+
+ if (!AliMUONCDB::CheckMapping()) return 0;
+
+ return AliMUONTrackerIO::ReadCapacitances(file,capaStore);
}
//_____________________________________________________________________________
/// Create a capacitance store. if defaultValues=true, all capa are 1.0,
/// otherwise they are from a gaussian with parameters defined in the
/// kCapa* constants below.
+
+ AliCodeTimerAutoGeneral("",0);
- TIter next(ManuList());
-
- AliMpIntPair* p;
+ if (!AliMUONCDB::CheckMapping()) return 0;
Int_t nchannels(0);
Int_t nmanus(0);
Int_t nmanusOK(0); // manus for which we got the serial number
- const Float_t kCapaMean(1.0);
- const Float_t kCapaSigma(0.5);
+ const Float_t kCapaMean(0.3);
+ const Float_t kCapaSigma(0.1);
+ const Float_t kInjectionGainMean(3);
+ const Float_t kInjectionGainSigma(1);
+
+ Int_t detElemId;
+ Int_t manuId;
- while ( ( p = (AliMpIntPair*)next() ) )
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
{
++nmanus;
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
- Int_t serialNumber = de->GetManuSerialFromId(manuId);
+ Int_t serialNumber = AliMpManuStore::Instance()->GetManuSerial(detElemId, manuId);
if ( serialNumber <= 0 ) continue;
++nmanusOK;
- const AliMpVSegmentation* seg =
- AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
-
AliMUONVCalibParam* capa = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
if (!capa)
{
- capa = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
+ capa = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
Bool_t ok = capaStore.Add(capa);
if (!ok)
{
- AliError(Form("Could not set serialNumber=%d manuId=%d",serialNumber,manuId));
+ AliErrorGeneral("AliMUONCDB", Form("Could not set serialNumber=%d manuId=%d",serialNumber,manuId));
}
}
for ( Int_t manuChannel = 0; manuChannel < capa->Size(); ++manuChannel )
{
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
- if (!pad.IsValid()) continue;
+ if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
++nchannels;
Float_t capaValue;
+ Float_t injectionGain;
if ( defaultValues )
{
capaValue = 1.0;
+ injectionGain = 1.0;
}
else
{
capaValue = GetRandom(kCapaMean,kCapaSigma,kTRUE);
+ injectionGain = GetRandom(kInjectionGainMean,kInjectionGainSigma,kTRUE);
}
capa->SetValueAsFloat(manuChannel,0,capaValue);
+ capa->SetValueAsFloat(manuChannel,1,injectionGain);
}
}
Float_t percent = 0;
if ( nmanus ) percent = 100*nmanusOK/nmanus;
- AliInfo(Form("%5d manus with serial number (out of %5d manus = %3.0f%%)",
+ AliInfoGeneral("AliMUONCDB", Form("%5d manus with serial number (out of %5d manus = %3.0f%%)",
nmanusOK,nmanus,percent));
- AliInfo(Form("%5d channels",nchannels));
+ AliInfoGeneral("AliMUONCDB", Form("%5d channels",nchannels));
if ( percent < 100 )
{
- AliWarning("Did not get all serial numbers. capaStore is incomplete !!!!");
+ AliWarningGeneral("AliMUONCDB", "Did not get all serial numbers. capaStore is incomplete !!!!");
}
return nchannels;
/// otherwise parameters are taken from gaussians with parameters
/// defined in the k* constants below.
- TIter next(ManuList());
+ AliCodeTimerAutoGeneral("",0);
- AliMpIntPair* p;
+ if (!AliMUONCDB::CheckMapping()) return 0;
Int_t nchannels(0);
Int_t nmanus(0);
const Int_t kSaturation(3000);
const Double_t kA0Mean(1.2);
- const Double_t kA0Sigma(0.1);
- const Double_t kA1Mean(1E-5);
- const Double_t kA1Sigma(1E-6);
+ const Double_t kA0Sigma(0.1);
+ const Double_t kA1Mean(1E-5);
+ const Double_t kA1Sigma(1E-6);
const Double_t kQualMean(0xFF);
const Double_t kQualSigma(0x10);
const Int_t kThresMean(1600);
- const Int_t kThresSigma(100);
+ const Int_t kThresSigma(100);
- while ( ( p = (AliMpIntPair*)next() ) )
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
{
++nmanus;
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
AliMUONVCalibParam* gain =
new AliMUONCalibParamNF(5,AliMpConstants::ManuNofChannels(),
detElemId,
manuId,
AliMUONVCalibParam::InvalidFloatValue());
-
- const AliMpVSegmentation* seg =
- AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
for ( Int_t manuChannel = 0; manuChannel < gain->Size(); ++manuChannel )
{
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
- if (!pad.IsValid()) continue;
+ if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
++nchannels;
Bool_t ok = gainStore.Add(gain);
if (!ok)
{
- AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
+ AliErrorGeneral("AliMUONCDB", Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
}
- if ( fMaxNofChannelsToGenerate > 0 && nchannels >= fMaxNofChannelsToGenerate ) break;
}
- AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
+ AliInfoGeneral("AliMUONCDB", Form("%d Manus and %d channels.",nmanus,nchannels));
return nchannels;
}
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONVStore& localBoardMasks) const
+AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONVStore& localBoardMasks)
{
/// Generate local trigger masks store. All masks are set to FFFF
+ AliCodeTimerAutoGeneral("",0);
+
Int_t ngenerated(0);
- // Generate fake mask values for 234 localboards and put that into
+ // Generate fake mask values for all localboards and put that into
// one single container (localBoardMasks)
- for ( Int_t i = 1; i <= 234; ++i )
+ for ( Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); ++i )
{
AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,i,0,0);
for ( Int_t x = 0; x < 2; ++x )
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeRegionalTriggerMaskStore(AliMUONVStore& rtm) const
+AliMUONCDB::MakeRegionalTriggerConfigStore(AliMUONRegionalTriggerConfig& rtm)
{
- /// Make a regional trigger masks store. All masks are set to 3F
+ /// Make a regional trigger config store. Mask is set to FFFF for each local board (Ch.F.)
- Int_t ngenerated(0);
- for ( Int_t i = 0; i < 16; ++i )
- {
- AliMUONVCalibParam* regionalBoard = new AliMUONCalibParamNI(1,16,i,0,0);
- for ( Int_t j = 0; j < 16; ++j )
- {
- regionalBoard->SetValueAsInt(j,0,0x3F);
- ++ngenerated;
- }
- rtm.Add(regionalBoard);
- }
+ AliCodeTimerAutoGeneral("",0);
- return ngenerated;
+ if ( ! rtm.ReadData(AliMpFiles::LocalTriggerBoardMapping()) ) {
+ AliErrorGeneral("AliMUONCDB", "Error when reading from mapping file");
+ return 0;
+ }
+
+ return rtm.GetNofTriggerCrates();
}
+
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeGlobalTriggerMaskStore(AliMUONVCalibParam& gtm) const
+AliMUONCDB::MakeGlobalTriggerConfigStore(AliMUONGlobalCrateConfig& gtm)
{
- /// Make a global trigger masks store. All masks set to FFF
+ /// Make a global trigger config store. All masks (disable) set to 0x00 for each Darc board (Ch.F.)
- Int_t ngenerated(0);
+ AliCodeTimerAutoGeneral("",0);
- for ( Int_t j = 0; j < 16; ++j )
- {
- gtm.SetValueAsInt(j,0,0xFFF);
- ++ngenerated;
- }
- return ngenerated;
+ return gtm.ReadData(AliMpFiles::GlobalTriggerBoardMapping());
}
+
//_____________________________________________________________________________
AliMUONTriggerLut*
-AliMUONCDB::MakeTriggerLUT(const char* file) const
+AliMUONCDB::MakeTriggerLUT(const char* file)
{
/// Make a triggerlut object, from a file.
+ AliCodeTimerAutoGeneral("",0);
+
AliMUONTriggerLut* lut = new AliMUONTriggerLut;
lut->ReadFromFile(file);
return lut;
//_____________________________________________________________________________
AliMUONTriggerEfficiencyCells*
-AliMUONCDB::MakeTriggerEfficiency(const char* file) const
+AliMUONCDB::MakeTriggerEfficiency(const char* file)
{
/// Make a trigger efficiency object from a file.
+ AliCodeTimerAutoGeneral("",0);
+
return new AliMUONTriggerEfficiencyCells(file);
}
//_____________________________________________________________________________
void
AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object,
- Int_t startRun, Int_t endRun, Bool_t defaultValues)
+ Int_t startRun, Int_t endRun,
+ const char* filename)
{
/// Write a given object to OCDB
- AliCDBId id(calibpath,startRun,endRun);
- AliCDBMetaData md;
- md.SetAliRootVersion(gROOT->GetVersion());
- if ( defaultValues )
- {
- md.SetComment("Test with default values");
- }
- else
- {
- md.SetComment("Test with random values");
- }
- md.SetResponsible("AliMUONCDB tester class");
+ TString comment(gSystem->ExpandPathName(filename));
- AliCDBManager* man = AliCDBManager::Instance();
- man->SetDefaultStorage(fCDBPath);
- man->Put(object,id,&md);
+ WriteToCDB(object, calibpath, startRun, endRun, comment.Data());
}
//_____________________________________________________________________________
-Int_t
-AliMUONCDB::MakeNeighbourStore(AliMUONVStore& neighbourStore)
+void
+AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object,
+ Int_t startRun, Int_t endRun, Bool_t defaultValues)
{
- /// Fill the neighbours store with, for each channel, a TObjArray of its
- /// neighbouring pads (including itself)
-
- AliInfo("Generating NeighbourStore. This will take a while. Please be patient.");
-
- TStopwatch timer;
-
- timer.Start(kTRUE);
+ /// Write a given object to OCDB
- TIter next(ManuList());
+ TString comment;
+ if ( defaultValues ) comment += "Test with default values";
+ else comment += "Test with random values";
- AliMpIntPair* p;
+ WriteToCDB(object, calibpath, startRun, endRun, comment.Data());
+}
+
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteToCDB(TObject* object, const char* calibpath, Int_t startRun, Int_t endRun,
+ const char* comment, const char* responsible)
+{
+ /// Write a given object to OCDB
- Int_t nchannels(0);
+ if (!AliMUONCDB::CheckOCDB(kTRUE)) return;
- TObjArray tmp;
+ AliCDBId id(calibpath,startRun,endRun);
+ AliCDBMetaData md;
+ md.SetAliRootVersion(gROOT->GetVersion());
+ md.SetComment(comment);
+ md.SetResponsible(responsible);
+ AliCDBManager::Instance()->Put(object,id,&md);
+}
+
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteLocalTriggerMasks(Int_t startRun, Int_t endRun)
+{
+ /// Write local trigger masks to OCDB
- while ( ( p = (AliMpIntPair*)next() ) )
- {
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
- const AliMpVSegmentation* seg =
- AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
-
- AliMUONVCalibParam* calibParam = static_cast<AliMUONVCalibParam*>(neighbourStore.FindObject(detElemId,manuId));
- if (!calibParam)
- {
- Int_t dimension(11);
- Int_t size(AliMpConstants::ManuNofChannels());
- Int_t defaultValue(-1);
- Int_t packingFactor(size);
-
- calibParam = new AliMUONCalibParamNI(dimension,size,detElemId,manuId,defaultValue,packingFactor);
- Bool_t ok = neighbourStore.Add(calibParam);
- if (!ok)
- {
- AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
- return -1;
- }
- }
-
- for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
- {
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
-
- if (pad.IsValid())
- {
- ++nchannels;
-
- seg->GetNeighbours(pad,tmp,true,true);
- Int_t nofPadNeighbours = tmp.GetEntriesFast();
-
- for ( Int_t i = 0; i < nofPadNeighbours; ++i )
- {
- AliMpPad* pad = static_cast<AliMpPad*>(tmp.At(i));
- Int_t x;
- Bool_t ok = calibParam->PackValues(pad->GetLocation().GetFirst(),pad->GetLocation().GetSecond(),x);
- if (!ok)
- {
- AliError("Could not pack value. Something is seriously wrong. Please check");
- StdoutToAliError(pad->Print(););
- return -1;
- }
- calibParam->SetValueAsInt(manuChannel,i,x);
- }
- }
- }
- }
-
- timer.Print();
-
- return nchannels;
-}
-
-//_____________________________________________________________________________
-void
-AliMUONCDB::SetMaxNofChannelsToGenerate(Int_t n)
-{
- /// Set the maximum number of channels to generate (used for testing only)
- /// n < 0 means no limit
- fMaxNofChannelsToGenerate = n;
-}
-
-//_____________________________________________________________________________
-void
-AliMUONCDB::WriteLocalTriggerMasks(Int_t startRun, Int_t endRun)
-{
- /// Write local trigger masks to OCDB
-
- AliMUONVStore* ltm = new AliMUON1DArray(235);
- Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
- AliInfo(Form("Ngenerated = %d",ngenerated));
- if (ngenerated>0)
+ AliMUONVStore* ltm = new AliMUON1DArray(AliMpConstants::TotalNofLocalBoards()+1);
+ Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
+ if (ngenerated>0)
{
WriteToCDB("MUON/Calib/LocalTriggerBoardMasks",ltm,startRun,endRun,true);
}
//_____________________________________________________________________________
void
-AliMUONCDB::WriteRegionalTriggerMasks(Int_t startRun, Int_t endRun)
+AliMUONCDB::WriteRegionalTriggerConfig(Int_t startRun, Int_t endRun)
{
/// Write regional trigger masks to OCDB
- AliMUONVStore* rtm = new AliMUON1DArray(16);
- Int_t ngenerated = MakeRegionalTriggerMaskStore(*rtm);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ AliMUONRegionalTriggerConfig* rtm = new AliMUONRegionalTriggerConfig();
+ Int_t ngenerated = MakeRegionalTriggerConfigStore(*rtm);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
{
- WriteToCDB("MUON/Calib/RegionalTriggerBoardMasks",rtm,startRun,endRun,true);
+ WriteToCDB("MUON/Calib/RegionalTriggerConfig",rtm,startRun,endRun,true);
}
delete rtm;
}
+
//_____________________________________________________________________________
void
-AliMUONCDB::WriteGlobalTriggerMasks(Int_t startRun, Int_t endRun)
+AliMUONCDB::WriteGlobalTriggerConfig(Int_t startRun, Int_t endRun)
{
/// Write global trigger masks to OCDB
- AliMUONVCalibParam* gtm = new AliMUONCalibParamNI(1,16,1,0,0);
+ AliMUONGlobalCrateConfig* gtm = new AliMUONGlobalCrateConfig();
- Int_t ngenerated = MakeGlobalTriggerMaskStore(*gtm);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ Int_t ngenerated = MakeGlobalTriggerConfigStore(*gtm);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
{
- WriteToCDB("MUON/Calib/GlobalTriggerBoardMasks",gtm,startRun,endRun,true);
+ WriteToCDB("MUON/Calib/GlobalTriggerCrateConfig",gtm,startRun,endRun,true);
}
delete gtm;
}
+
//_____________________________________________________________________________
void
AliMUONCDB::WriteTriggerLut(Int_t startRun, Int_t endRun)
//_____________________________________________________________________________
void
-AliMUONCDB::WriteNeighbours(Int_t startRun, Int_t endRun)
+AliMUONCDB::WriteHV(Bool_t defaultValues,
+ Int_t startRun, Int_t endRun)
{
- /// Write neighbours to OCDB
+ /// generate HV values (either cste = 1500 V) if defaultValues=true or random
+ /// if defaultValues=false, see makeHVStore) and
+ /// store them into CDB located at cdbpath, with a validity period
+ /// ranging from startRun to endRun
- AliMUONVStore* neighbours = new AliMUON2DMap(kTRUE);
- Int_t ngenerated = MakeNeighbourStore(*neighbours);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ TMap* hvStore = new TMap;
+ Int_t ngenerated = MakeHVStore(*hvStore,defaultValues);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
{
- WriteToCDB("MUON/Calib/Neighbours",neighbours,startRun,endRun,true);
+ WriteToCDB("MUON/Calib/HV",hvStore,startRun,endRun,defaultValues);
}
- delete neighbours;
+ delete hvStore;
}
//_____________________________________________________________________________
void
-AliMUONCDB::WriteHV(Bool_t defaultValues,
+AliMUONCDB::WriteTriggerDCS(Bool_t defaultValues,
Int_t startRun, Int_t endRun)
{
- /// generate HV values (either cste = 1500 V) if defaultValues=true or random
- /// if defaultValues=false, see makeHVStore) and
+ /// generate Trigger HV and current values (either const if defaultValues=true or random
+ /// if defaultValues=false, see makeTriggerDCSStore) and
/// store them into CDB located at cdbpath, with a validity period
/// ranging from startRun to endRun
- TMap* hvStore = new TMap;
- Int_t ngenerated = MakeHVStore(*hvStore,defaultValues);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ TMap* triggerDCSStore = new TMap;
+ Int_t ngenerated = MakeTriggerDCSStore(*triggerDCSStore,defaultValues);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
{
- WriteToCDB("MUON/Calib/HV",hvStore,startRun,endRun,defaultValues);
+ WriteToCDB("MUON/Calib/TriggerDCS",triggerDCSStore,startRun,endRun,defaultValues);
}
- delete hvStore;
+ delete triggerDCSStore;
}
//_____________________________________________________________________________
/// store them into CDB located at cdbpath, with a validity period
/// ranging from startRun to endRun
- AliMUONVStore* pedestalStore = new AliMUON2DMap(true);
+ AliMUONVStore* pedestalStore = Create2DMap();
Int_t ngenerated = MakePedestalStore(*pedestalStore,defaultValues);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
WriteToCDB("MUON/Calib/Pedestals",pedestalStore,startRun,endRun,defaultValues);
delete pedestalStore;
}
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteOccupancyMap(Bool_t defaultValues,
+ Int_t startRun, Int_t endRun)
+{
+ /// generate occupancy map values (either empty one if defaultValues=true, or
+ /// random one, see MakeOccupancyMapStore) and
+ /// store them into CDB located at cdbpath, with a validity period
+ /// ranging from startRun to endRun
+
+ AliMUONVStore* occupancyMapStore = Create2DMap();
+ Int_t ngenerated = MakeOccupancyMapStore(*occupancyMapStore,defaultValues);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
+ WriteToCDB("MUON/Calib/OccupancyMap",occupancyMapStore,startRun,endRun,defaultValues);
+ delete occupancyMapStore;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteRejectList(Bool_t defaultValues,
+ Int_t startRun, Int_t endRun)
+{
+ /// generate reject list values (either empty one if defaultValues=true, or
+ /// random one, see MakeRejectListStore) and
+ /// store them into CDB located at cdbpath, with a validity period
+ /// ranging from startRun to endRun
+
+ AliMUONRejectList* rl = MakeRejectListStore(defaultValues);
+ WriteToCDB("MUON/Calib/RejectList",rl,startRun,endRun,defaultValues);
+ delete rl;
+}
+
//_____________________________________________________________________________
void
/// store them into CDB located at cdbpath, with a validity period
/// ranging from startRun to endRun
- AliMUONVStore* gainStore = new AliMUON2DMap(true);
+ AliMUONVStore* gainStore = Create2DMap();
Int_t ngenerated = MakeGainStore(*gainStore,defaultValues);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
WriteToCDB("MUON/Calib/Gains",gainStore,startRun,endRun,defaultValues);
delete gainStore;
}
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteCapacitances(const char* filename,
+ Int_t startRun, Int_t endRun)
+{
+ /// read manu capacitance and injection gain values from file
+ /// and store them into CDB located at cdbpath, with a validity period
+ /// ranging from startRun to endRun
+
+ AliMUONVStore* capaStore = new AliMUON1DMap(16828);
+ Int_t ngenerated = MakeCapacitanceStore(*capaStore,filename);
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
+ if ( ngenerated > 0 )
+ {
+ WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,filename);
+ }
+ delete capaStore;
+}
+
//_____________________________________________________________________________
void
AliMUONCDB::WriteCapacitances(Bool_t defaultValues,
AliMUONVStore* capaStore = new AliMUON1DMap(16828);
Int_t ngenerated = MakeCapacitanceStore(*capaStore,defaultValues);
- AliInfo(Form("Ngenerated = %d",ngenerated));
+ AliInfoGeneral("AliMUONCDB", Form("Ngenerated = %d",ngenerated));
WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,defaultValues);
delete capaStore;
}
//_____________________________________________________________________________
void
-AliMUONCDB::WriteTrigger(Int_t startRun, Int_t endRun)
+AliMUONCDB::WriteTrigger(Bool_t defaultValues, Int_t startRun, Int_t endRun)
{
/// Writes all Trigger related calibration to CDB
+ WriteTriggerDCS(defaultValues,startRun,endRun);
WriteLocalTriggerMasks(startRun,endRun);
- WriteRegionalTriggerMasks(startRun,endRun);
- WriteGlobalTriggerMasks(startRun,endRun);
+ WriteRegionalTriggerConfig(startRun,endRun);
+ WriteGlobalTriggerConfig(startRun,endRun);
WriteTriggerLut(startRun,endRun);
WriteTriggerEfficiency(startRun,endRun);
}
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteConfig(Int_t startRun, Int_t endRun)
+{
+ /// Write complete tracker configuration to OCDB
+ ostringstream lines;
+ TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+ AliMpBusPatch* bp;
+ while ( ( bp = static_cast<AliMpBusPatch*>(next()) ) )
+ {
+ for (Int_t imanu = 0; imanu < bp->GetNofManus(); ++imanu)
+ {
+ lines << bp->GetId() << " " << bp->GetManuId(imanu) << endl;
+ }
+ }
+
+ AliMUON2DMap config(kTRUE);
+
+ AliMUONTrackerIO::DecodeConfig(lines.str().c_str(),config);
+
+ WriteToCDB("MUON/Calib/Config",&config,startRun,endRun,kTRUE);
+}
+
//_____________________________________________________________________________
void
AliMUONCDB::WriteTracker(Bool_t defaultValues, Int_t startRun, Int_t endRun)
WritePedestals(defaultValues,startRun,endRun);
WriteGains(defaultValues,startRun,endRun);
WriteCapacitances(defaultValues,startRun,endRun);
- WriteNeighbours(startRun,endRun);
+ WriteOccupancyMap(defaultValues,startRun,endRun);
+ WriteRejectList(defaultValues,startRun,endRun);
+ WriteConfig(startRun,endRun);
+}
+
+//_____________________________________________________________________________
+void
+AliMUONCDB::ShowCapacitances()
+{
+ /// Show briefly the number of capa values we have in the OCDB,
+ /// and the list of manu that are actually in the config and for which
+ /// we miss the capa (if any).
+
+ if (!AliMUONCDB::CheckOCDB()) return;
+
+ AliMUONCDB::LoadMapping();
+
+ if (!AliMUONCDB::CheckMapping()) return;
+
+ AliCDBEntry* e = AliCDBManager::Instance()->Get("MUON/Calib/Config");
+
+ if (!e) return ;
+
+ AliMUONVStore* config = static_cast<AliMUONVStore*>(e->GetObject());
+
+ e = AliCDBManager::Instance()->Get("MUON/Calib/Capacitances");
+
+ if (!e) return;
+
+ AliMUONVStore* capacitances = static_cast<AliMUONVStore*>(e->GetObject());
+
+ AliInfoGeneral("ShowCapacitances",Form("%d capacitances are in OCDB",capacitances->GetSize()));
+
+ TIter nextManu(config->CreateIterator());
+ AliMUONVCalibParam* param;
+
+ while ( ( param = static_cast<AliMUONVCalibParam*>(nextManu()) ) )
+ {
+ Int_t detElemId = param->ID0();
+ Int_t manuId = param->ID1();
+
+ Int_t serialNumber
+ = AliMpManuStore::Instance()->GetManuSerial(detElemId, manuId);
+
+ if (serialNumber<0)
+ {
+ AliErrorGeneral("ShowCapacitances",Form("Did not find serial for DE %04d MANUID %04d",detElemId,manuId));
+ }
+ else
+ {
+ AliMUONVCalibParam* capa = static_cast<AliMUONVCalibParam*>(capacitances->FindObject(serialNumber));
+ if (!capa)
+ {
+ AliErrorGeneral("ShowCapacitances",Form("Did not find capacitance for DE %04d MANUID %04d SERIAL %d",detElemId,manuId,serialNumber));
+ }
+ }
+ }
+
+}
+
+//_____________________________________________________________________________
+void
+AliMUONCDB::ShowConfig(Bool_t withStatusMap)
+{
+ /// Dumps the current tracker configuration, i.e. number and identity of missing buspatches
+ /// If statusMap is true, will also take into account the status map to report the number
+ /// of good channels
+
+ if (!AliMUONCDB::CheckOCDB()) return;
+
+ AliMUONCDB::LoadMapping();
+
+ if (!AliMUONCDB::CheckMapping()) return;
+
+ AliCDBEntry* e = AliCDBManager::Instance()->Get("MUON/Calib/Config");
+
+ if (!e) return ;
+
+ AliMUONVStore* config = static_cast<AliMUONVStore*>(e->GetObject());
+
+ AliMUONPadStatusMapMaker* statusMapMaker(0x0);
+ AliMUONCalibrationData* cd(0x0);
+ AliMUONPadStatusMaker* statusMaker(0x0);
+
+ if ( withStatusMap )
+ {
+ cd = new AliMUONCalibrationData(AliCDBManager::Instance()->GetRun());
+
+ statusMaker = new AliMUONPadStatusMaker(*cd);
+
+ AliMUONRecoParam* recoParam = AliMUONCDB::LoadRecoParam();
+
+ if (!recoParam)
+ {
+ AliErrorGeneral("AliMUONCDB::ShowConfig","Cannot get recoParams from OCDB !");
+ return;
+ }
+
+ statusMaker->SetLimits(*recoParam);
+
+ UInt_t mask = recoParam->PadGoodnessMask();
+
+ delete recoParam;
+
+ const Bool_t deferredInitialization = kFALSE;
+
+ statusMapMaker = new AliMUONPadStatusMapMaker(*cd,mask,deferredInitialization);
+ }
+
+ TIter nextManu(config->CreateIterator());
+ AliMUONVCalibParam* param;
+
+ AliMpExMap buspatches;
+
+ while ( ( param = static_cast<AliMUONVCalibParam*>(nextManu()) ) )
+ {
+ Int_t detElemId = param->ID0();
+ Int_t manuId = param->ID1();
+ Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
+ if ( buspatches.GetValue(busPatchId) == 0x0 )
+ {
+ buspatches.Add(busPatchId,new TObjString(Form("BP%04d",busPatchId)));
+ }
+ }
+
+ TArrayI removed(buspatches.GetSize());
+
+ TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+ AliMpBusPatch* bp;
+ Int_t n(0);
+ Int_t nok(0);
+ Int_t nremoved(0);
+
+ // accounting of bus patches first
+
+ while ( ( bp = static_cast<AliMpBusPatch*>(next())))
+ {
+ if ( buspatches.GetValue(bp->GetId()) )
+ {
+ ++nok;
+ }
+ else
+ {
+ removed.SetAt(bp->GetId(),nremoved++);
+ }
+ }
+
+ // accounting of channels
+
+ AliMpManuIterator it;
+
+ Int_t totalNumberOfChannels(0);
+ Int_t removedChannels(0);
+ Int_t badChannels(0);
+ Int_t badAndRemovedChannels(0);
+ Int_t badOrRemovedChannels(0);
+
+ Int_t detElemId, manuId;
+
+ while ( it.Next(detElemId,manuId) )
+ {
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+ for ( Int_t i = 0; i < AliMpConstants::ManuNofChannels(); ++i )
+ {
+ Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
+
+ if ( de->IsConnectedChannel(manuId,i) )
+ {
+ ++totalNumberOfChannels;
+ Bool_t badBusPatch = ( buspatches.GetValue(busPatchId) == 0x0 );
+
+ if ( withStatusMap )
+ {
+ Bool_t badChannel = ( ( statusMapMaker->StatusMap(detElemId,manuId,i) & AliMUONPadStatusMapMaker::SelfDeadMask() ) != 0);
+ if ( badChannel ) ++badChannels;
+ if ( badBusPatch && badChannel ) ++badAndRemovedChannels;
+ if ( badBusPatch || badChannel ) ++badOrRemovedChannels;
+ }
+
+ if ( badBusPatch) ++removedChannels;
+ }
+ }
+ }
+
+
+ Int_t* indices = new Int_t[nremoved];
+
+ TMath::Sort(nremoved,removed.GetArray(),indices,kFALSE);
+
+ for ( Int_t i = 0; i < nremoved; ++i )
+ {
+ Int_t busPatchId = removed[indices[i]];
+ bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
+ bp->Print();
+ }
+
+ delete[] indices;
+
+ cout << endl;
+ cout << Form("Bus patches n=%3d nok=%3d nremoved=%3d",n,nok,nremoved) << endl;
+
+ cout << Form("Channels n=%6d nremoved=%6d bad=%6d bad and removed=%6d bad or removed=%6d",
+ totalNumberOfChannels,removedChannels,badChannels,badAndRemovedChannels,badOrRemovedChannels) << endl;
+
+ if (totalNumberOfChannels>0)
+ {
+ cout << Form("Percentage of readout channels %5.1f %%",removedChannels*100.0/totalNumberOfChannels) << endl;
+ if ( withStatusMap )
+ {
+ cout << Form("Percentage of non useable channels (bad or removed) %5.1f %%",
+ badOrRemovedChannels*100.0/totalNumberOfChannels) << endl;
+ }
+ }
+
+
+ delete statusMapMaker;
+ delete cd;
+ delete statusMaker;
+}
+
+//______________________________________________________________________________
+void AliMUONCDB::ReadIntegers(const char* filename, std::vector<int>& integers)
+{
+ /// Read integers from filename, where integers are either
+ /// separated by "," or by return carriage
+ ifstream in(gSystem->ExpandPathName(filename));
+ int i;
+
+ std::set<int> runset;
+
+ char line[10000];
+
+ in.getline(line,10000,'\n');
+
+ TString sline(line);
+
+ if (sline.Contains(","))
+ {
+ TObjArray* a = sline.Tokenize(",");
+ TIter next(a);
+ TObjString* s;
+ while ( ( s = static_cast<TObjString*>(next()) ) )
+ {
+ runset.insert(s->String().Atoi());
+ }
+ delete a;
+ }
+ else
+ {
+ runset.insert(sline.Atoi());
+
+ while ( in >> i )
+ {
+ runset.insert(i);
+ }
+ }
+
+ for ( std::set<int>::const_iterator it = runset.begin(); it != runset.end(); ++it )
+ {
+ integers.push_back((*it));
+ }
+
+ std::sort(integers.begin(),integers.end());
+}
+
+//______________________________________________________________________________
+void AliMUONCDB::ShowFaultyBusPatches(const char* runlist, double occLimit,
+ const char* outputBaseName,
+ const char* ocdbPath)
+{
+ /// Shows the list of bus patches above a given occupancy limit,
+ /// for each run in the runlist
+
+ AliLog::GetRootLogger()->SetGlobalLogLevel(AliLog::kError);
+
+ // AliLog::SetPrintType(AliLog::kInfo,kFALSE);
+ // AliLog::SetPrintType(AliLog::kWarning,kFALSE);
+ // gErrorIgnoreLevel=kError; // to avoid all the TAlienFile::Open messages...
+
+ AliCDBManager* man = AliCDBManager::Instance();
+
+ man->SetDefaultStorage(ocdbPath);
+
+ Bool_t first(kTRUE);
+
+ std::vector<int> runnumbers;
+
+ ReadIntegers(runlist,runnumbers);
+
+ AliMUON2DMap bpValues(kFALSE);
+
+ std::ofstream outfile(Form("%s.txt",outputBaseName));
+
+ for ( unsigned int i = 0 ; i < runnumbers.size(); ++i )
+ {
+ int runNumber = runnumbers[i];
+
+ man->SetRun(runNumber);
+
+ if ( first )
+ {
+ AliMpCDB::LoadAll();
+ first = kFALSE;
+ }
+
+ AliCDBEntry* e = man->Get("MUON/Calib/OccupancyMap",runNumber);
+
+ if (!e)
+ {
+ AliErrorGeneral("AliMUONCDB::ShowFaultyBusPatches",
+ Form("Could not get OccupancyMap for run %09d",runNumber));
+ continue;
+ }
+
+ AliMUONVStore* occmap = static_cast<AliMUONVStore*>(e->GetObject());
+
+ AliMUONTrackerData td("occ","occ",*occmap);
+
+ TIter nextBP(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+ AliMpBusPatch* bp;
+ std::set<int> buspatches;
+ Double_t sumn = 1000.0;
+
+ while ( ( bp = static_cast<AliMpBusPatch*>(nextBP()) ) )
+ {
+ Double_t occ = td.BusPatch(bp->GetId(),2);
+
+ if (occ>occLimit)
+ {
+ buspatches.insert(bp->GetId());
+
+ AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(bpValues.FindObject(bp->GetId()));
+
+ if (!param)
+ {
+ param = new AliMUONCalibParamND(5, 1, bp->GetId(), 0);
+ bpValues.Add(param);
+
+ Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(bp->GetId());
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+
+ Int_t nchannels(0);
+
+ for ( Int_t imanu = 0; imanu < bp->GetNofManus(); ++imanu )
+ {
+ Int_t manuId = bp->GetManuId(imanu);
+ nchannels += de->NofChannelsInManu(manuId);
+ }
+
+ param->SetValueAsDouble(0,2,sumn);
+ param->SetValueAsDouble(0,3,nchannels);
+ param->SetValueAsDouble(0,4,1);
+ }
+
+ Double_t sumw = sumn*(param->ValueAsDouble(0)/sumn+1.0/runnumbers.size());
+ Double_t sumw2 = 0.0; //(sumn-1)*ey*ey+sumw*sumw/sumn;
+
+ param->SetValueAsDouble(0,0,sumw);
+ param->SetValueAsDouble(0,1,sumw2);
+
+ }
+ }
+
+ outfile << Form("RUN %09d",runNumber);
+
+ for ( std::set<int>::const_iterator bit = buspatches.begin(); bit != buspatches.end(); ++bit )
+ {
+ outfile << Form(" %4d",*bit);
+ }
+ outfile << endl;
+ }
+
+ outfile.close();
+
+ const char* name = "BPfailureRate";
+
+ AliMUONTrackerData* mpData = new AliMUONTrackerData(name,name,bpValues,2);
+ mpData->SetDimensionName(0,name);
+
+ TFile f(Form("%s.root",outputBaseName),"recreate");
+ mpData->Write();
+ f.Close();
+
+ cout << Form("Results are in %s.txt and %s.root",outputBaseName,outputBaseName) << endl;
+
+ gSystem->Exec(Form("cat %s.txt",outputBaseName));
+
+}
+
+//______________________________________________________________________________
+void AliMUONCDB::CheckHV(Int_t runNumber, Int_t verbose)
+{
+ /// Check the HV values in OCDB for a given run
+
+ TList messages;
+ messages.SetOwner(kTRUE);
+
+ Bool_t patched(kTRUE);
+
+ if (!AliCDBManager::Instance()->IsDefaultStorageSet())
+ {
+ AliCDBManager::Instance()->SetDefaultStorage("raw://");
+ }
+
+ AliCDBManager::Instance()->SetRun(runNumber);
+
+ LoadMapping();
+
+ AliMUONCalibrationData::CreateHV(runNumber,0,patched,&messages);
+
+ AliMUONCalibrationData cd(runNumber,true);
+
+ AliMUONPadStatusMaker statusMaker(cd);
+
+ AliMUONRecoParam* rp = AliMUONCDB::LoadRecoParam();
+
+ if (!rp)
+ {
+ AliErrorGeneral("AliMUONCDB::CheckHV","Could not get RecoParam !!!");
+ return;
+ }
+
+ statusMaker.SetLimits(*rp);
+
+ TIter next(&messages);
+ TObjString* s;
+ AliMpDCSNamer hvNamer("TRACKER");
+ AliMUONLogger log;
+
+ while ( ( s = static_cast<TObjString*>(next()) ) )
+ {
+ TObjArray* a = s->String().Tokenize(":");
+
+ TString name(static_cast<TObjString*>(a->At(0))->String());
+
+ if ( name.Contains("sw") || name.Contains("SUMMARY") ) {delete a; continue;}
+
+ Int_t index = hvNamer.DCSIndexFromDCSAlias(name.Data());
+
+ Int_t detElemId = hvNamer.DetElemIdFromDCSAlias(name.Data());
+
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+
+ if (!de)
+ {
+ AliErrorGeneral("AliMUONCDB::CheckHV",Form("Could not get detElemId from dcsAlias %s",name.Data()));
+ delete a;
+ continue;
+ }
+
+ Int_t manuId;
+
+ if ( index >= 0 )
+ {
+ const AliMpArrayI* array = de->ManusForHV(index);
+ manuId = array->GetValue(0);
+ }
+ else
+
+ {
+ AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(de->GetBusPatchId(0));
+
+ manuId = bp->GetManuId(0);
+ }
+
+ Int_t status = statusMaker.HVStatus(detElemId,manuId);
+
+ log.Log(AliMUONPadStatusMaker::AsString(status).Data());
+
+ s->String() += Form(" (DE %4d) ",detElemId);
+ s->String() += AliMUONPadStatusMaker::AsString(status).Data();
+
+ delete a;
+ }
+
+ TIter nextMessage(&messages);
+ TObjString* msg;
+
+ while ( ( msg = static_cast<TObjString*>(nextMessage()) ) )
+ {
+ if ( verbose > 0 || msg->String().Contains("SUMMARY") )
+ {
+ AliInfoGeneral("AliMUONCDB::CheckHV",Form("RUN %09d HVchannel %s",runNumber,msg->String().Data()));
+ }
+ }
+
+ TString lmsg;
+ Int_t occurance;
+ TString totalLog;
+
+ while (log.Next(lmsg,occurance))
+ {
+ totalLog += Form("%s(%d)",lmsg.Data(),occurance);
+ totalLog += " | ";
+ }
+
+ AliInfoGeneral("AliMUONCDB::CheckHV",Form("RUN %09d %s",runNumber,totalLog.Data()));
+
+ // one last loop to get the list of problematic HV channels
+ nextMessage.Reset();
+
+ while ( ( msg = static_cast<TObjString*>(nextMessage()) ) )
+ {
+ if ( msg->String().Contains("HV ") )
+ {
+ AliInfoGeneral("AliMUONCDB::CheckHV",Form(" Problem at %s",msg->String().Data()));
+ }
+ }
+
+ AliCDBManager::Instance()->ClearCache();
}
+
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff