#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 "AliMUONCalibParamNF.h"
#include "AliMUONCalibParamNI.h"
#include "AliMUONConstants.h"
-#include "AliMUONHVNamer.h"
+#include "AliMUONTrackerIO.h"
#include "AliMUONTriggerEfficiencyCells.h"
#include "AliMUONTriggerLut.h"
#include "AliMUONVStore.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVCalibParam.h"
+#include "AliMUONGlobalCrateConfig.h"
+#include "AliMUONRegionalTriggerConfig.h"
+
#include "AliMpCDB.h"
#include "AliMpConstants.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 "AliDCSValue.h"
+#include "AliLog.h"
+
#include <Riostream.h>
#include <TArrayI.h>
#include <TClass.h>
#include <TSystem.h>
#include <TMath.h>
+
/// \cond CLASSIMP
ClassImp(AliMUONCDB)
/// \endcond
namespace
{
-//_____________________________________________________________________________
+ //_____________________________________________________________________________
+AliMUONVStore* Create2DMap()
+{
+ return new AliMUON2DMap(true);
+}
+
+ //_____________________________________________________________________________
void getBoundaries(const AliMUONVStore& store, Int_t dim,
Float_t* xmin, Float_t* xmax)
{
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)
{
- /// ctor
+ /// ctor
+ // Load mapping
+ if ( ! AliMpCDB::LoadDDLStore() ) {
+ AliFatal("Could not access mapping from OCDB !");
+ }
+
+ if ( ! AliMpCDB::LoadManuStore() ) {
+ AliFatal("Could not access run-dependent mapping from OCDB !");
+ }
}
//_____________________________________________________________________________
AliMUONCDB::~AliMUONCDB()
{
/// dtor
- delete fManuList;
-}
-
-//_____________________________________________________________________________
-TList*
-AliMUONCDB::ManuList()
-{
- /// return (and create if necessary) the list of (de,manu) pairs
- if (!fManuList)
- {
- AliInfo("Generating ManuList...");
- AliCDBManager::Instance()->SetDefaultStorage(fCDBPath);
- AliMpCDB::LoadMpSegmentation();
- AliMpCDB::LoadDDLStore();
- fManuList = AliMpManuList::ManuList();
- AliInfo("Manu List generated.");
- }
- return fManuList;
}
//_____________________________________________________________________________
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;
{
/// Create a HV store
- AliMUONHVNamer hvNamer;
+ AliMpDCSNamer hvNamer("TRACKER");
TObjArray* aliases = hvNamer.GenerateAliases();
return nChannels+nSwitch;
}
+//_____________________________________________________________________________
+Int_t
+AliMUONCDB::MakeTriggerDCSStore(TMap& aliasMap, Bool_t defaultValues)
+{
+ /// Create a Trigger HV and Currents store
+
+ 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());
+ 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;
+
+ AliInfo(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)
-
- TIter next(ManuList());
-
- AliMpIntPair* p;
+
+ AliCodeTimerAuto("");
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);
AliInfo(Form("%d Manus and %d channels.",nmanus,nchannels));
return nchannels;
-
}
//_____________________________________________________________________________
-Int_t
-AliMUONCDB::MakeCapacitanceStore(AliMUONVStore& capaStore, const char* file)
+Int_t
+AliMUONCDB::MakeKillMapStore(AliMUONVStore& killMapStore)
{
- ifstream in(gSystem->ExpandPathName(file));
- if (in.bad()) return 0;
+ /// Create a kill map.
- Int_t ngenerated(0);
+ AliCodeTimerAuto("");
+
+ Int_t nchannels(0);
+ Int_t nmanus(0);
+
+ const Int_t kChannels(AliMpConstants::ManuNofChannels());
- char line[1024];
- Int_t serialNumber(-1);
- AliMUONVCalibParam* param(0x0);
+ const Float_t kFractionOfDeadManu(0.1); // within [0.,1.]
- while ( in.getline(line,1024,'\n') )
+ if ( kFractionOfDeadManu == 0.0 ) return 0.0;
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
{
- if ( isdigit(line[0]) )
+ // skip a given fraction of manus
+ if ( gRandom->Uniform() > kFractionOfDeadManu) continue;
+
+ ++nmanus;
+
+ AliMUONVCalibParam* kill = new AliMUONCalibParamNI(1,kChannels,detElemId,manuId,0);
+
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+
+ for ( Int_t manuChannel = 0; manuChannel < kChannels; ++manuChannel )
{
- 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;
+ if ( ! de->IsConnectedChannel(manuId,manuChannel) ) continue;
+
+ ++nchannels;
+
+ kill->SetValueAsInt(manuChannel,0,1);
+
+ }
+ Bool_t ok = killMapStore.Add(kill);
+ if (!ok)
+ {
+ AliError(Form("Could not set DetElemId=%d manuId=%d",detElemId,manuId));
}
- 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;
+ if ( fMaxNofChannelsToGenerate > 0 && nchannels >= fMaxNofChannelsToGenerate ) break;
}
- in.close();
+ 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
- return ngenerated;
+ 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.
-
- TIter next(ManuList());
-
- AliMpIntPair* p;
+
+ AliCodeTimerAuto("");
Int_t nchannels(0);
Int_t nmanus(0);
const Float_t kCapaSigma(0.1);
const Float_t kInjectionGainMean(3);
const Float_t kInjectionGainSigma(1);
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ 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);
+ 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)
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;
/// otherwise parameters are taken from gaussians with parameters
/// defined in the k* constants below.
- TIter next(ManuList());
-
- AliMpIntPair* p;
+ AliCodeTimerAuto("");
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);
+
+ 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();
-
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;
{
/// 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
+ // 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) const
{
- /// 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);
- }
+ AliCodeTimerAuto("");
- return ngenerated;
+ if ( ! rtm.ReadData(AliMpFiles::LocalTriggerBoardMapping()) ) {
+ AliErrorStream() << "Error when reading from mapping file" << endl;
+ return 0;
+ }
+
+ return rtm.GetNofTriggerCrates();
}
+
//_____________________________________________________________________________
Int_t
-AliMUONCDB::MakeGlobalTriggerMaskStore(AliMUONVCalibParam& gtm) const
+AliMUONCDB::MakeGlobalTriggerConfigStore(AliMUONGlobalCrateConfig& gtm) const
{
- /// 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);
+ AliCodeTimerAuto("");
- 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
{
/// 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);
}
{
/// 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);
+ TString comment(gSystem->ExpandPathName(filename));
+
+ WriteToCDB(object, calibpath, startRun, endRun, comment.Data());
}
//_____________________________________________________________________________
{
/// Write a given object to OCDB
+ TString comment;
+ if ( defaultValues ) comment += "Test with default values";
+ else comment += "Test with random values";
+
+ 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
+
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");
-
+ md.SetComment(comment);
+ md.SetResponsible(responsible);
AliCDBManager* man = AliCDBManager::Instance();
- man->SetDefaultStorage(fCDBPath);
+ if (!man->IsDefaultStorageSet()) man->SetDefaultStorage(fCDBPath);
man->Put(object,id,&md);
}
/// 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.");
+ AliCodeTimerAuto("");
- TStopwatch timer;
-
- timer.Start(kTRUE);
-
- TIter next(ManuList());
-
- 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;
+
+ AliMpManuIterator it;
- while ( ( p = (AliMpIntPair*)next() ) )
+ while ( it.Next(detElemId,manuId) )
{
- Int_t detElemId = p->GetFirst();
- Int_t manuId = p->GetSecond();
-
const AliMpVSegmentation* seg =
AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
{
- AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,manuChannel),kFALSE);
+ AliMpPad pad = seg->PadByLocation(manuId,manuChannel,kFALSE);
if (pad.IsValid())
{
for ( Int_t i = 0; i < nofPadNeighbours; ++i )
{
- AliMpPad* pad = static_cast<AliMpPad*>(tmp.At(i));
+ AliMpPad* p = 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");
- StdoutToAliError(pad->Print(););
- return -1;
- }
+// Bool_t ok =
+ calibParam->PackValues(p->GetManuId(),p->GetManuChannel(),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;
}
{
/// Write local trigger masks to OCDB
- AliMUONVStore* ltm = new AliMUON1DArray(235);
+ AliMUONVStore* ltm = new AliMUON1DArray(AliMpConstants::TotalNofLocalBoards()+1);
Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
AliInfo(Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
//_____________________________________________________________________________
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);
+ AliMUONRegionalTriggerConfig* rtm = new AliMUONRegionalTriggerConfig();
+ Int_t ngenerated = MakeRegionalTriggerConfigStore(*rtm);
AliInfo(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);
+ Int_t ngenerated = MakeGlobalTriggerConfigStore(*gtm);
AliInfo(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)
{
/// Write neighbours to OCDB
- AliMUONVStore* neighbours = new AliMUON2DMap(kTRUE);
+ AliMUONVStore* neighbours = Create2DMap();
Int_t ngenerated = MakeNeighbourStore(*neighbours);
AliInfo(Form("Ngenerated = %d",ngenerated));
if (ngenerated>0)
delete hvStore;
}
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteTriggerDCS(Bool_t defaultValues,
+ Int_t startRun, Int_t endRun)
+{
+ /// 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* triggerDCSStore = new TMap;
+ Int_t ngenerated = MakeTriggerDCSStore(*triggerDCSStore,defaultValues);
+ AliInfo(Form("Ngenerated = %d",ngenerated));
+ if (ngenerated>0)
+ {
+ WriteToCDB("MUON/Calib/TriggerDCS",triggerDCSStore,startRun,endRun,defaultValues);
+ }
+ delete triggerDCSStore;
+}
+
//_____________________________________________________________________________
void
AliMUONCDB::WritePedestals(Bool_t defaultValues,
/// 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));
WriteToCDB("MUON/Calib/Pedestals",pedestalStore,startRun,endRun,defaultValues);
delete pedestalStore;
}
+//_____________________________________________________________________________
+void
+AliMUONCDB::WriteKillMap(Bool_t defaultValues,
+ Int_t startRun, Int_t endRun)
+{
+ /// generate kill map values (either empty one if defaultValues=true, or
+ /// random one, see MakeKillMapStore) and
+ /// store them into CDB located at cdbpath, with a validity period
+ /// ranging from startRun to endRun
+
+ AliMUONVStore* killMapStore = Create2DMap();
+ if ( !defaultValues )
+ {
+ Int_t ngenerated = MakeKillMapStore(*killMapStore);
+ AliInfo(Form("Ngenerated = %d",ngenerated));
+ }
+ WriteToCDB("MUON/Calib/KillMap",killMapStore,startRun,endRun,defaultValues);
+ delete killMapStore;
+}
+
//_____________________________________________________________________________
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));
WriteToCDB("MUON/Calib/Gains",gainStore,startRun,endRun,defaultValues);
//_____________________________________________________________________________
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);
}
WriteGains(defaultValues,startRun,endRun);
WriteCapacitances(defaultValues,startRun,endRun);
WriteNeighbours(startRun,endRun);
+ WriteKillMap(startRun,endRun,defaultValues);
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff