/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONCDB
///
/// Helper class to experience the OCDB
/// For more information, please see READMECDB
///
// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONCDB.h"
+#include "AliCodeTimer.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliDCSValue.h"
#include "AliMUONCalibParamNF.h"
#include "AliMUONCalibParamNI.h"
#include "AliMUONConstants.h"
-#include "AliMUONHVNamer.h"
-#include "AliMUONObjectPair.h"
#include "AliMUONTriggerEfficiencyCells.h"
#include "AliMUONTriggerLut.h"
-#include "AliMUONV2DStore.h"
+#include "AliMUONVStore.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVCalibParam.h"
-#include "AliMUONVDataIterator.h"
+#include "AliMpCDB.h"
+#include "AliMpConstants.h"
#include "AliMpDDLStore.h"
#include "AliMpDEIterator.h"
#include "AliMpDEManager.h"
#include "AliMpDetElement.h"
-#include "AliMpManuList.h"
+#include "AliMpHVNamer.h"
+#include "AliMpManuIterator.h"
#include "AliMpSegmentation.h"
#include "AliMpStationType.h"
#include "AliMpVSegmentation.h"
#include <TRandom.h>
#include <TStopwatch.h>
#include <TSystem.h>
+#include <TMath.h>
/// \cond CLASSIMP
ClassImp(AliMUONCDB)
/// \endcond
-const Int_t AliMUONCDB::fgkMaxNofChannelsPerManu=64;
-
namespace
{
-//_____________________________________________________________________________
-void getBoundaries(const AliMUONV2DStore& store,
- Float_t& x0min, Float_t& x0max,
- Float_t& x1min, Float_t& x1max)
+ //_____________________________________________________________________________
+AliMUONVStore* Create2DMap()
+{
+ return new AliMUON2DMap(true);
+}
+
+ //_____________________________________________________________________________
+void getBoundaries(const AliMUONVStore& store, Int_t dim,
+ Float_t* xmin, Float_t* xmax)
{
- x0min=1E30;
- x0max=-1E30;
- x1min=1E30;
- x1max=-1E30;
+ /// Assuming the store contains AliMUONVCalibParam objects, compute the
+ /// limits of the value contained in the VCalibParam, for each of its dimensions
+ /// xmin and xmax must be of dimension dim
- AliMUONVDataIterator* it = store.Iterator();
+ for ( Int_t i = 0; i < dim; ++i )
+ {
+ xmin[i]=1E30;
+ xmax[i]=-1E30;
+ }
- AliMUONObjectPair* p;
+ TIter next(store.CreateIterator());
+ AliMUONVCalibParam* value;
- while ( ( p = dynamic_cast<AliMUONObjectPair*>(it->Next() ) ) )
+ while ( ( value = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
{
- AliMpIntPair* dm = dynamic_cast<AliMpIntPair*>(p->Key());
- AliMUONVCalibParam* value = dynamic_cast<AliMUONVCalibParam*>(p->Value());
-
- Int_t detElemId = dm->GetFirst();
- Int_t manuId = dm->GetSecond();
+ Int_t detElemId = value->ID0();
+ Int_t manuId = value->ID1();
const AliMpVSegmentation* seg =
AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
if (!pad.IsValid()) continue;
- Float_t x0 = value->ValueAsFloat(manuChannel,0);
-
- x0min = TMath::Min(x0min,x0);
- x0max = TMath::Max(x0max,x0);
- if ( value->Dimension()>1 )
+ for ( Int_t i = 0; i < dim; ++i )
{
- Float_t x1 = value->ValueAsFloat(manuChannel,1);
- x1min = TMath::Min(x1min,x1);
- x1max = TMath::Max(x1max,x1);
+ Float_t x0 = value->ValueAsFloat(manuChannel,i);
+
+ xmin[i] = TMath::Min(xmin[i],x0);
+ xmax[i] = TMath::Max(xmax[i],x0);
}
}
- if (it->IsOwner()) delete p;
- }
+ }
+
+ for ( Int_t i = 0; i < dim; ++i )
+ {
+ if ( TMath::Abs(xmin[i]-xmax[i]) < 1E-3 )
+ {
+ xmin[i] -= 1;
+ xmax[i] += 1;
+ }
+ }
+}
+
+//_____________________________________________________________________________
+Double_t GetRandom(Double_t mean, Double_t sigma, Bool_t mustBePositive)
+{
+ Double_t x(-1);
+ if ( mustBePositive )
+ {
+ while ( x < 0 )
+ {
+ x = gRandom->Gaus(mean,sigma);
+ }
+ }
+ else
+ {
+ x = gRandom->Gaus(mean,sigma);
+ }
+ return x;
}
}
AliMUONCDB::AliMUONCDB(const char* cdbpath)
: TObject(),
fCDBPath(cdbpath),
- fManuList(AliMpManuList::ManuList())
+ fMaxNofChannelsToGenerate(-1)
{
- /// ctor
+ /// ctor
+ AliMpDDLStore::ReadData();
}
//_____________________________________________________________________________
AliMUONCDB::~AliMUONCDB()
{
/// dtor
- delete fManuList;
}
//_____________________________________________________________________________
-AliMUONV2DStore*
-AliMUONCDB::Diff(AliMUONV2DStore& store1, AliMUONV2DStore& store2,
+AliMUONVStore*
+AliMUONCDB::Diff(AliMUONVStore& store1, AliMUONVStore& store2,
const char* opt)
{
/// creates a store which contains store1-store2
/// if opt="abs" the difference is absolute one,
/// if opt="rel" then what is stored is (store1-store2)/store1
+ /// if opt="percent" then what is stored is rel*100
+ ///
/// WARNING Works only for stores which holds AliMUONVCalibParam objects
TString sopt(opt);
sopt.ToUpper();
- if ( !sopt.Contains("ABS") && !sopt.Contains("REL") )
+ if ( !sopt.Contains("ABS") && !sopt.Contains("REL") && !sopt.Contains("PERCENT") )
{
- AliErrorClass(Form("opt %s not supported. Only ABS or REL are",opt));
+ AliErrorClass(Form("opt %s not supported. Only ABS, REL, PERCENT are",opt));
return 0x0;
}
- AliMUONV2DStore* d = static_cast<AliMUONV2DStore*>(store1.Clone());
+ AliMUONVStore* d = static_cast<AliMUONVStore*>(store1.Clone());
- AliMUONVDataIterator* it = d->Iterator();
+ TIter next(d->CreateIterator());
- AliMUONObjectPair* p;
+ AliMUONVCalibParam* param;
- while ( ( p = dynamic_cast<AliMUONObjectPair*>(it->Next() ) ) )
+ while ( ( param = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
{
- AliMpIntPair* dm = dynamic_cast<AliMpIntPair*>(p->Key());
- //FIXME: this might happen (if a full manu is missing, for instance)
- //handle it.
- if (!dm)
- {
- cerr << "dm is null : FIXME: this might happen !" << endl;
- delete d;
- return 0;
- }
- AliMUONVCalibParam* param = dynamic_cast<AliMUONVCalibParam*>(p->Value());
- //FIXMENOT: this should *not* happen
- if (!param)
- {
- cerr << "param is null" << endl;
- delete d;
- return 0;
- }
+ Int_t detElemId = param->ID0();
+ Int_t manuId = param->ID1();
- AliMUONVCalibParam* param2 = dynamic_cast<AliMUONVCalibParam*>(store2.Get(dm->GetFirst(),dm->GetSecond()));
+ AliMUONVCalibParam* param2 = dynamic_cast<AliMUONVCalibParam*>(store2.FindObject(detElemId,manuId));
//FIXME: this might happen. Handle it.
if (!param2)
{
{
value = param->ValueAsFloat(i,j) - param2->ValueAsFloat(i,j);
}
- else if ( sopt.Contains("REL") )
+ else if ( sopt.Contains("REL") || sopt.Contains("PERCENT") )
{
if ( param->ValueAsFloat(i,j) )
{
{
continue;
}
+ if ( sopt.Contains("PERCENT") ) value *= 100.0;
}
param->SetValueAsFloat(i,j,value);
}
}
- if (it->IsOwner()) delete p;
}
return d;
}
//_____________________________________________________________________________
void
-AliMUONCDB::Plot(const AliMUONV2DStore& store, const char* name, Int_t nbins)
+AliMUONCDB::Plot(const AliMUONVStore& store, const char* name, Int_t nbins)
{
- /// Make a plot of the first 1 or 2 dimensions of the AliMUONVCalibParam
+ /// Make histograms of each dimension of the AliMUONVCalibParam
/// contained inside store.
/// It produces histograms named name_0, name_1, etc...
- Float_t x0min, x0max, x1min, x1max;
-
- getBoundaries(store,x0min,x0max,x1min,x1max);
-
- if ( x0min > x0max )
- {
- cerr << Form("Something is wrong with boundaries : x0(min,max)=%e,%e",
- x0min,x0max) << endl;
- return;
- }
-
- if ( TMath::Abs(x0min-x0max) < 1E-3 )
- {
- x0min -= 1;
- x0max += 1;
- }
-
- TH1* h0 = new TH1F(Form("%s_0",name),Form("%s_0",name),
- nbins,x0min,x0max);
-
- TH1* h1(0);
-
- if ( x1max > x1min )
- {
- h1 = new TH1F(Form("%s_1",name),Form("%s_1",name),
- nbins,x1min,x1max);
- }
-
- TIter next(fManuList);
- AliMpIntPair* p;
+ TIter next(store.CreateIterator());
+ AliMUONVCalibParam* param;
Int_t n(0);
- Int_t nPerStation[7];
+ const Int_t kNStations = AliMpConstants::NofTrackingChambers()/2;
+ Int_t* nPerStation = new Int_t[kNStations];
+ TH1** h(0x0);
- for ( Int_t i = 0; i < 7; ++i ) nPerStation[i]=0;
+ for ( Int_t i = 0; i < kNStations; ++i ) nPerStation[i]=0;
- while ( ( p = (AliMpIntPair*)next() ) )
+ while ( ( param = static_cast<AliMUONVCalibParam*>(next()) ) )
{
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
- Int_t station = AliMpDEManager::GetChamberId(detElemId);
+ if (!h)
+ {
+ Int_t dim = param->Dimension();
+ h = new TH1*[dim];
+ Float_t* xmin = new Float_t[dim];
+ Float_t* xmax = new Float_t[dim];
+ getBoundaries(store,dim,xmin,xmax);
+
+ for ( Int_t i = 0; i < dim; ++i )
+ {
+ 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()));
+ }
+ }
+
+ Int_t detElemId = param->ID0();
+ Int_t manuId = param->ID1();
+ Int_t station = AliMpDEManager::GetChamberId(detElemId)/2;
const AliMpVSegmentation* seg =
AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
- AliMUONVCalibParam* value =
- dynamic_cast<AliMUONVCalibParam*>(store.Get(detElemId,manuId));
-
- if (value)
+ for ( Int_t manuChannel = 0; manuChannel < param->Size(); ++manuChannel )
{
- for ( Int_t manuChannel = 0; manuChannel < value->Size(); ++manuChannel )
- {
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
- if (!pad.IsValid()) continue;
+ AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
+ if (!pad.IsValid()) continue;
- ++n;
- ++nPerStation[station];
- Float_t x = value->ValueAsFloat(manuChannel,0);
- if ( x>1E4 )
- {
- AliInfo(Form("DE %d Manu %d Ch %d x=%e",detElemId,manuId,manuChannel,x));
- }
- h0->Fill(x);
- if (h1)
- {
- h1->Fill(value->ValueAsFloat(manuChannel,1));
- }
+ ++n;
+ ++nPerStation[station];
+
+ for ( Int_t dim = 0; dim < param->Dimension(); ++dim )
+ {
+ h[dim]->Fill(param->ValueAsFloat(manuChannel,dim));
}
}
- else
- {
- AliWarning(Form("Got a null value for DE=%d manuId=%d",detElemId,manuId));
- }
- }
+ }
- AliInfo(Form("Number of channels = %d",n));
- for ( Int_t i = 0; i < 7; ++i )
+ for ( Int_t i = 0; i < kNStations; ++i )
{
AliInfo(Form("Station %d %d ",(i+1),nPerStation[i]));
}
+
+ AliInfo(Form("Number of channels = %d",n));
+
+ delete[] nPerStation;
}
//_____________________________________________________________________________
{
/// Create a HV store
- AliMUONHVNamer hvNamer;
- TRandom random;
+ AliMpHVNamer hvNamer;
TObjArray* aliases = hvNamer.GenerateAliases();
if (!defaultValues)
{
- Float_t r = random.Uniform();
+ Float_t r = gRandom->Uniform();
if ( r < 0.007 ) value = kFALSE;
}
for ( UInt_t timeStamp = 0; timeStamp < 60*15; timeStamp += 120 )
{
Float_t value = 1500;
- if (!defaultValues) value = random.Gaus(1750,62.5);
+ if (!defaultValues) value = GetRandom(1750,62.5,true);
AliDCSValue* dcsValue = new AliDCSValue(value,timeStamp);
valueSet->Add(dcsValue);
}
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakePedestalStore(AliMUONV2DStore& pedestalStore, Bool_t defaultValues)
+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)
-
- TIter next(fManuList);
-
- AliMpIntPair* p;
+
+ AliCodeTimerAuto("");
Int_t nchannels(0);
Int_t nmanus(0);
- Bool_t replace = kFALSE;
-
- const Int_t kChannels(64);
+ 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);
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
- while ( ( p = (AliMpIntPair*)next() ) )
+ while ( it.Next(detElemId,manuId) )
{
++nmanus;
- AliMUONVCalibParam* ped = new AliMUONCalibParamNF(2,kChannels,AliMUONVCalibParam::InvalidFloatValue());
-
- Int_t detElemId = p->GetFirst();
-
- Int_t manuId = p->GetSecond();
-
- const AliMpVSegmentation* seg =
- AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
+
+ AliMUONVCalibParam* ped =
+ new AliMUONCalibParamNF(2,kChannels,detElemId,manuId,AliMUONVCalibParam::InvalidFloatValue());
+
+ 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;
}
else
{
- meanPedestal = -1;
- while ( meanPedestal < 0 )
- {
- meanPedestal = gRandom->Gaus(kPedestalMeanMean,kPedestalMeanSigma);
- }
- sigmaPedestal = -1;
- while ( sigmaPedestal < 0 )
+ Bool_t positive(kTRUE);
+ meanPedestal = 0.0;
+ while ( meanPedestal == 0.0 ) // avoid strict zero
{
- sigmaPedestal = gRandom->Gaus(kPedestalSigmaMean,kPedestalSigmaSigma);
+ meanPedestal = GetRandom(kPedestalMeanMean,kPedestalMeanSigma,positive);
}
+ sigmaPedestal = GetRandom(kPedestalSigmaMean,kPedestalSigmaSigma,positive);
}
ped->SetValueAsFloat(manuChannel,0,meanPedestal);
ped->SetValueAsFloat(manuChannel,1,sigmaPedestal);
}
- Bool_t ok = pedestalStore.Set(detElemId,manuId,ped,replace);
+ Bool_t ok = pedestalStore.Add(ped);
if (!ok)
{
AliError(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));
return nchannels;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONCDB::MakeCapacitanceStore(AliMUONVStore& capaStore, const char* file)
+{
+ /// Read the capacitance values from file and append them to the capaStore
+ AliCodeTimerAuto(Form("file=%s",file));
+
+ ifstream in(gSystem->ExpandPathName(file));
+ if (in.bad()) return 0;
+
+ Int_t ngenerated(0);
+
+ char line[1024];
+ Int_t serialNumber(-1);
+ AliMUONVCalibParam* param(0x0);
+
+ while ( in.getline(line,1024,'\n') )
+ {
+ if ( isdigit(line[0]) )
+ {
+ serialNumber = atoi(line);
+ param = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
+ if (param)
+ {
+ AliError(Form("serialNumber %d appears several times !",serialNumber));
+ capaStore.Clear();
+ break;
+ }
+ param = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
+ Bool_t ok = capaStore.Add(param);
+ if (!ok)
+ {
+ AliError(Form("Could not set serialNumber=%d",serialNumber));
+ continue;
+ }
+ continue;
+ }
+ Int_t channel;
+ Float_t capaValue;
+ Float_t injectionGain;
+ sscanf(line,"%d %f %f",&channel,&capaValue,&injectionGain);
+ AliDebug(1,Form("SerialNumber %10d Channel %3d Capa %f injectionGain %f",
+ serialNumber,channel,capaValue,injectionGain));
+ param->SetValueAsFloat(channel,0,capaValue);
+ param->SetValueAsFloat(channel,1,injectionGain);
+ ++ngenerated;
+ }
+
+ in.close();
+
+ return ngenerated;
}
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeCapacitanceStore(AliMUONV1DStore& capaStore, Bool_t defaultValues)
+AliMUONCDB::MakeCapacitanceStore(AliMUONVStore& capaStore, Bool_t defaultValues)
{
/// 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.
-
- TIter next(fManuList);
-
- AliMpIntPair* p;
+
+ AliCodeTimerAuto("");
Int_t nchannels(0);
Int_t nmanus(0);
Int_t nmanusOK(0); // manus for which we got the serial number
+
+ 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;
- Bool_t replace = kFALSE;
-
- const Float_t kCapaMean(1.0);
- const Float_t kCapaSigma(0.5);
+ AliMpManuIterator it;
- while ( ( p = (AliMpIntPair*)next() ) )
+ 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);
- if ( serialNumber > 0 ) ++nmanusOK;
+ if ( serialNumber <= 0 ) continue;
- const AliMpVSegmentation* seg =
- AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
-
- AliMUONVCalibParam* capa = static_cast<AliMUONVCalibParam*>(capaStore.Get(serialNumber));
+ ++nmanusOK;
+
+ AliMUONVCalibParam* capa = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
if (!capa)
{
- capa = new AliMUONCalibParamNF(1,fgkMaxNofChannelsPerManu,1.0);
- Bool_t ok = capaStore.Set(serialNumber,capa,replace);
+ 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));
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 = -1;
- while ( capaValue < 0 )
- {
- capaValue = gRandom->Gaus(kCapaMean,kCapaSigma);
- }
+ capaValue = GetRandom(kCapaMean,kCapaSigma,kTRUE);
+ injectionGain = GetRandom(kInjectionGainMean,kInjectionGainSigma,kTRUE);
}
capa->SetValueAsFloat(manuChannel,0,capaValue);
+ capa->SetValueAsFloat(manuChannel,1,injectionGain);
}
}
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeGainStore(AliMUONV2DStore& gainStore, Bool_t defaultValues)
+AliMUONCDB::MakeGainStore(AliMUONVStore& gainStore, Bool_t defaultValues)
{
- /// Create a gain store. if defaultValues=true, all gain are 1.0,
- /// otherwise they are from a gaussian with parameters defined in the
- /// kGain* constants below.
-
- TIter next(fManuList);
+ /// Create a gain store. if defaultValues=true, all gains set so that
+ /// charge = (adc-ped)
+ ///
+ /// otherwise parameters are taken from gaussians with parameters
+ /// defined in the k* constants below.
- AliMpIntPair* p;
+ AliCodeTimerAuto("");
Int_t nchannels(0);
Int_t nmanus(0);
-
- Bool_t replace = kFALSE;
-
- const Double_t kSaturation(3000);
- const Double_t kGainMean(1.0);
- const Double_t kGainSigma(0.05);
-
- while ( ( p = (AliMpIntPair*)next() ) )
+
+ 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 kQualMean(0xFF);
+ const Double_t kQualSigma(0x10);
+ const Int_t kThresMean(1600);
+ const Int_t kThresSigma(100);
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
{
++nmanus;
+
AliMUONVCalibParam* gain =
- new AliMUONCalibParamNF(2,fgkMaxNofChannelsPerManu,
+ new AliMUONCalibParamNF(5,AliMpConstants::ManuNofChannels(),
+ detElemId,
+ manuId,
AliMUONVCalibParam::InvalidFloatValue());
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
- 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;
- Float_t meanGain;
- Float_t saturation(kSaturation);
-
if ( defaultValues )
{
- meanGain = 1.0;
+ gain->SetValueAsFloat(manuChannel,0,1.0);
+ gain->SetValueAsFloat(manuChannel,1,0.0);
+ gain->SetValueAsInt(manuChannel,2,4095);
+ gain->SetValueAsInt(manuChannel,3,1);
+ gain->SetValueAsInt(manuChannel,4,kSaturation);
}
else
{
- meanGain = -1;
- while ( meanGain < 0 )
- {
- meanGain = gRandom->Gaus(kGainMean,kGainSigma);
- }
+ Bool_t positive(kTRUE);
+ gain->SetValueAsFloat(manuChannel,0,GetRandom(kA0Mean,kA0Sigma,positive));
+ gain->SetValueAsFloat(manuChannel,1,GetRandom(kA1Mean,kA1Sigma,!positive));
+ gain->SetValueAsInt(manuChannel,2,(Int_t)TMath::Nint(GetRandom(kThresMean,kThresSigma,positive)));
+ gain->SetValueAsInt(manuChannel,3,(Int_t)TMath::Nint(GetRandom(kQualMean,kQualSigma,positive)));
+ gain->SetValueAsInt(manuChannel,4,kSaturation);
}
- gain->SetValueAsFloat(manuChannel,0,meanGain);
- gain->SetValueAsFloat(manuChannel,1,saturation);
}
- Bool_t ok = gainStore.Set(detElemId,manuId,gain,replace);
+ Bool_t ok = gainStore.Add(gain);
if (!ok)
{
AliError(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));
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONV1DStore& localBoardMasks) const
+AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONVStore& localBoardMasks) const
{
/// Generate local trigger masks store. All masks are set to FFFF
+ AliCodeTimerAuto("");
+
Int_t ngenerated(0);
// Generate fake mask values for 234 localboards and put that into
// one single container (localBoardMasks)
for ( Int_t i = 1; i <= 234; ++i )
{
- AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8);
+ AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,i,0,0);
for ( Int_t x = 0; x < 2; ++x )
{
for ( Int_t y = 0; y < 4; ++y )
++ngenerated;
}
}
- localBoardMasks.Set(i,localBoard,kFALSE);
+ localBoardMasks.Add(localBoard);
}
return ngenerated;
}
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeRegionalTriggerMaskStore(AliMUONV1DStore& rtm) const
+AliMUONCDB::MakeRegionalTriggerMaskStore(AliMUONVStore& rtm) const
{
/// Make a regional trigger masks store. All masks are set to 3F
+ AliCodeTimerAuto("");
+
Int_t ngenerated(0);
for ( Int_t i = 0; i < 16; ++i )
{
- AliMUONVCalibParam* regionalBoard = new AliMUONCalibParamNI(1,16);
+ AliMUONVCalibParam* regionalBoard = new AliMUONCalibParamNI(1,16,i,0,0);
for ( Int_t j = 0; j < 16; ++j )
{
regionalBoard->SetValueAsInt(j,0,0x3F);
++ngenerated;
}
- rtm.Set(i,regionalBoard,kFALSE);
+ rtm.Add(regionalBoard);
}
return ngenerated;
{
/// Make a global trigger masks store. All masks set to FFF
+ AliCodeTimerAuto("");
+
Int_t ngenerated(0);
for ( Int_t j = 0; j < 16; ++j )
{
/// Make a triggerlut object, from a file.
+ AliCodeTimerAuto("");
+
AliMUONTriggerLut* lut = new AliMUONTriggerLut;
lut->ReadFromFile(file);
return lut;
{
/// Make a trigger efficiency object from a file.
+ AliCodeTimerAuto("");
+
return new AliMUONTriggerEfficiencyCells(file);
}
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object,
+ 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());
+ md.SetComment(gSystem->ExpandPathName(filename));
+ md.SetResponsible("Uploaded using AliMUONCDB class");
+ AliCDBManager* man = AliCDBManager::Instance();
+ man->SetDefaultStorage(fCDBPath);
+ man->Put(object,id,&md);
+}
+
//_____________________________________________________________________________
void
AliMUONCDB::WriteToCDB(const char* calibpath, TObject* object,
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeNeighbourStore(AliMUONV2DStore& neighbourStore)
+AliMUONCDB::MakeNeighbourStore(AliMUONVStore& neighbourStore)
{
/// Fill the neighbours store with, for each channel, a TObjArray of its
/// neighbouring pads (including itself)
- TStopwatch timer;
-
- timer.Start(kTRUE);
+ AliCodeTimerAuto("");
- TIter next(fManuList);
-
- AliMpIntPair* p;
+ AliInfo("Generating NeighbourStore. This will take a while. Please be patient.");
Int_t nchannels(0);
TObjArray tmp;
+
+ Int_t detElemId;
+ Int_t manuId;
- while ( ( p = (AliMpIntPair*)next() ) )
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
{
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
const AliMpVSegmentation* seg =
AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
- AliMUONVCalibParam* calibParam = static_cast<AliMUONVCalibParam*>(neighbourStore.Get(detElemId,manuId));
+ AliMUONVCalibParam* calibParam = static_cast<AliMUONVCalibParam*>(neighbourStore.FindObject(detElemId,manuId));
if (!calibParam)
{
Int_t dimension(11);
- Int_t size(64);
+ Int_t size(AliMpConstants::ManuNofChannels());
Int_t defaultValue(-1);
- Int_t packingFactor(64);
+ Int_t packingFactor(size);
- calibParam = new AliMUONCalibParamNI(dimension,size,defaultValue,packingFactor);
- Bool_t ok = neighbourStore.Set(detElemId,manuId,calibParam,kFALSE);
+ 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));
}
}
- for ( Int_t manuChannel = 0; manuChannel < 64; ++manuChannel )
+ for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
{
AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
for ( Int_t i = 0; i < nofPadNeighbours; ++i )
{
- AliMpPad* pad = static_cast<AliMpPad*>(tmp.At(i));
+ AliMpPad* pad = static_cast<AliMpPad*>(tmp.UncheckedAt(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");
- return -1;
- }
+// 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
- AliMUONV1DStore* ltm = new AliMUON1DArray(235);
+ AliMUONVStore* ltm = new AliMUON1DArray(235);
Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
AliInfo(Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
{
/// Write regional trigger masks to OCDB
- AliMUONV1DStore* rtm = new AliMUON1DArray(16);
+ AliMUONVStore* rtm = new AliMUON1DArray(16);
Int_t ngenerated = MakeRegionalTriggerMaskStore(*rtm);
AliInfo(Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
{
/// Write global trigger masks to OCDB
- AliMUONVCalibParam* gtm = new AliMUONCalibParamNI(1,16);
+ AliMUONVCalibParam* gtm = new AliMUONCalibParamNI(1,16,1,0,0);
Int_t ngenerated = MakeGlobalTriggerMaskStore(*gtm);
AliInfo(Form("Ngenerated = %d",ngenerated));
{
/// Write neighbours to OCDB
- AliMUONV2DStore* neighbours = new AliMUON2DMap(kTRUE);
+ AliMUONVStore* neighbours = Create2DMap();
Int_t ngenerated = MakeNeighbourStore(*neighbours);
AliInfo(Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
/// store them into CDB located at cdbpath, with a validity period
/// ranging from startRun to endRun
- AliMUONV2DStore* pedestalStore = new AliMUON2DMap(true);
+ AliMUONVStore* pedestalStore = Create2DMap();
Int_t ngenerated = MakePedestalStore(*pedestalStore,defaultValues);
AliInfo(Form("Ngenerated = %d",ngenerated));
WriteToCDB("MUON/Calib/Pedestals",pedestalStore,startRun,endRun,defaultValues);
/// store them into CDB located at cdbpath, with a validity period
/// ranging from startRun to endRun
- AliMUONV2DStore* gainStore = new AliMUON2DMap(true);
+ AliMUONVStore* gainStore = Create2DMap();
Int_t ngenerated = MakeGainStore(*gainStore,defaultValues);
AliInfo(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);
+ AliInfo(Form("Ngenerated = %d",ngenerated));
+ if ( ngenerated > 0 )
+ {
+ WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,filename);
+ }
+ delete capaStore;
+}
+
//_____________________________________________________________________________
void
AliMUONCDB::WriteCapacitances(Bool_t defaultValues,
/// store them into CDB located at cdbpath, with a validity period
/// ranging from startRun to endRun
- AliMUONV1DStore* capaStore = new AliMUON1DMap(16828);
+ AliMUONVStore* capaStore = new AliMUON1DMap(16828);
Int_t ngenerated = MakeCapacitanceStore(*capaStore,defaultValues);
AliInfo(Form("Ngenerated = %d",ngenerated));
WriteToCDB("MUON/Calib/Capacitances",capaStore,startRun,endRun,defaultValues);
WriteCapacitances(defaultValues,startRun,endRun);
WriteNeighbours(startRun,endRun);
}
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff