kill some tracker channels, based on initial analysis of the data.
(Laurent)
return nchannels;
}
+//_____________________________________________________________________________
+Int_t
+AliMUONCDB::MakeKillMapStore(AliMUONVStore& killMapStore)
+{
+ /// Create a kill map.
+
+ AliCodeTimerAuto("");
+
+ Int_t nchannels(0);
+ Int_t nmanus(0);
+
+ const Int_t kChannels(AliMpConstants::ManuNofChannels());
+
+ const Float_t kFractionOfDeadManu(0.1); // within [0.,1.]
+
+ if ( kFractionOfDeadManu == 0.0 ) return 0.0;
+
+ Int_t detElemId;
+ Int_t manuId;
+
+ AliMpManuIterator it;
+
+ while ( it.Next(detElemId,manuId) )
+ {
+ // 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 )
+ {
+ 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));
+ }
+ 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)
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
WriteGains(defaultValues,startRun,endRun);
WriteCapacitances(defaultValues,startRun,endRun);
WriteNeighbours(startRun,endRun);
+ WriteKillMap(startRun,endRun,defaultValues);
}
Int_t MakeCapacitanceStore(AliMUONVStore& capaStore, Bool_t defaultValues);
Int_t MakeCapacitanceStore(AliMUONVStore& capaStore, const char* file);
Int_t MakeGainStore(AliMUONVStore& gainStore, Bool_t defaultValues);
+ Int_t MakeKillMapStore(AliMUONVStore& killMapStore);
Int_t MakeLocalTriggerMaskStore(AliMUONVStore& ltm) const;
Int_t MakeRegionalTriggerConfigStore(AliMUONRegionalTriggerConfig& rtm) const;
void WriteGains(Bool_t defaultValues, Int_t startRun, Int_t endRun=AliCDBRunRange::Infinity());
void WriteCapacitances(Bool_t defaultValues, Int_t startRun=0, Int_t endRun=AliCDBRunRange::Infinity());
void WriteCapacitances(const char* file, Int_t startRun=0, Int_t endRun=AliCDBRunRange::Infinity());
+ void WriteKillMap(Bool_t defaultValues, Int_t startRun, Int_t endRun=AliCDBRunRange::Infinity());
void WriteLocalTriggerMasks(Int_t startRun=0, Int_t endRun=AliCDBRunRange::Infinity());
void WriteRegionalTriggerConfig(Int_t startRun=0, Int_t endRun=AliCDBRunRange::Infinity());
fTriggerLut(0x0),
fTriggerEfficiency(0x0),
fCapacitances(0x0),
-fNeighbours(0x0)
+fNeighbours(0x0),
+fKillMap(0x0)
{
/// Default ctor.
{
Gains();
Pedestals();
+ KillMap();
HV();
TriggerDCS();
LocalTriggerBoardMasks(0);
return 0x0;
}
+//_____________________________________________________________________________
+AliMUONVStore*
+AliMUONCalibrationData::CreateKillMap(Int_t runNumber, Int_t* startOfValidity)
+{
+ /// Create a new killmap store from the OCDB for a given run
+ return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/KillMap",startOfValidity));
+}
+
//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::CreatePedestals(Int_t runNumber, Int_t* startOfValidity)
return 0x0;
}
+//_____________________________________________________________________________
+AliMUONVStore*
+AliMUONCalibrationData::KillMap() const
+{
+ /// Get kill map
+ if (!fKillMap)
+ {
+ fKillMap = CreateKillMap(fRunNumber);
+ }
+ return fKillMap;
+}
+
+//_____________________________________________________________________________
+AliMUONVCalibParam*
+AliMUONCalibrationData::KillMap(Int_t detElemId, Int_t manuId) const
+{
+ /// Return the killmap for a given (detElemId, manuId) pair.
+ /// A return value of 0x0 is quite possible, meaning the manu should
+ /// not be killed ;-)
+
+ AliMUONVStore* killMap = KillMap();
+ if (!killMap)
+ {
+ return 0x0;
+ }
+
+ return static_cast<AliMUONVCalibParam*>(killMap->FindObject(detElemId,manuId));
+}
+
+
//_____________________________________________________________________________
AliMUONVStore*
AliMUONCalibrationData::Pedestals() const
/// Create a local trigger mask store (which must be deleted) for a given run
static AliMUONVStore* CreateLocalTriggerBoardMasks(Int_t runNumber, Int_t* startOfValidity=0);
+ /// Create a kill map store (which must be deleted) from OCDB for the given run
+ static AliMUONVStore* CreateKillMap(Int_t runNumber, Int_t* startOfValidity=0);
+
/// Create a pedestal store (which must be deleted) from OCDB for the given run
static AliMUONVStore* CreatePedestals(Int_t runNumber, Int_t* startOfValidity=0);
/// Get the pedestal store
AliMUONVStore* Pedestals() const;
-
+
+ /// Get the kill map store
+ AliMUONVStore* KillMap() const;
+
+ /// Get the kill map calibration object for channels within (detElemId,manuId).
+ AliMUONVCalibParam* KillMap(Int_t detElemId, Int_t manuId) const;
+
/// Get the Pedestal calibration object for channels within (detElemId,manuId).
AliMUONVCalibParam* Pedestals(Int_t detElemId, Int_t manuId) const;
mutable AliMUONVStore* fCapacitances; //!< Manu capacitances
mutable AliMUONVStore* fNeighbours; //!< list of neighbours for all channels
- ClassDef(AliMUONCalibrationData,8) // Storage for all MUON calibration data.
+ mutable AliMUONVStore* fKillMap; //!< kill map
+
+ ClassDef(AliMUONCalibrationData,9) // Storage for all MUON calibration data.
};
#endif
fHV(new TExMap),
fPedestals(calibData.Pedestals()),
fGains(calibData.Gains()),
-fTrackerData(0x0)
+fTrackerData(0x0),
+fKillMap(calibData.KillMap())
{
/// ctor
AliDebug(1,Form("ped store %s gain store %s",
/// dtor.
delete fStatus;
delete fHV;
+ delete fKillMap;
}
//_____________________________________________________________________________
if ( otherStatus & kManuOccupancyTooHigh ) s+="& manu occupancy too high ";
if ( otherStatus & kManuOccupancyTooLow ) s+="& manu occupancy too low ";
+ if ( otherStatus & kKilled ) s+="& killed";
if ( s[0] == '&' ) s[0] = ' ';
AliMUONVCalibParam* gains = static_cast<AliMUONVCalibParam*>(fGains->FindObject(detElemId,manuId));
+ AliMUONVCalibParam* kill(0x0);
+
+ if ( fKillMap )
+ {
+ kill = static_cast<AliMUONVCalibParam*>(fKillMap->FindObject(detElemId,manuId));
+ }
+
Int_t hvStatus = HVStatus(detElemId,manuId);
Int_t otherStatus = OtherStatus(detElemId,manuId);
{
gainStatus = kGainMissing;
}
+
+ if ( kill && (kill->ValueAsInt(manuChannel,0) > 0) )
+ {
+ otherStatus |= kKilled;
+ }
Int_t status = BuildStatus(pedStatus,hvStatus,gainStatus,otherStatus);
enum EOtherStatus
{
kManuOccupancyTooLow = (1<<1),
- kManuOccupancyTooHigh = (1<<2)
+ kManuOccupancyTooHigh = (1<<2),
+ kKilled = (1<<3)
};
const AliMUONCalibrationData& fkCalibrationData; //!< helper class to get data access (not owner)
AliMUONVTrackerData* fTrackerData; //!< to get occupancies...
+ AliMUONVStore* fKillMap; //!< to selectively force killing of some channels
+
ClassDef(AliMUONPadStatusMaker,0) // Creates pad statuses from ped,gain,hv
};
fOCDBTypes->AddEntry("Pedestals",0);
fOCDBTypes->AddEntry("Gains",1);
fOCDBTypes->AddEntry("Capacitances",2);
- fOCDBTypes->AddEntry("HV",3);
+ fOCDBTypes->AddEntry("HV",3);
+ fOCDBTypes->AddEntry("KillMap",4);
fOCDBTypes->Select(0);
fOCDBTypes->Resize(100,20);
fACFTypes->AddEntry("Pedestals",0);
fACFTypes->AddEntry("Gains",1);
- fACFTypes->AddEntry("Capacitances",2);
+ fACFTypes->AddEntry("Capacitances",2);
+ fACFTypes->AddEntry("HV",3);
+ fACFTypes->AddEntry("KillMap",4);
fACFTypes->Select(0);
fACFTypes->Resize(100,20);
}
for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
fBypassSt45 = 0;
- fPadGoodnessMask = 0x400BE80;
+ fPadGoodnessMask = 0xC00BE80;
fMaxTriggerTracks = 100;
fMaxTrackCandidates = 10000;
fGainThresLimits[0] = 0;
fGainThresLimits[1] = 4095;
- fPadGoodnessMask = 0x8080;
+ fPadGoodnessMask = 0x8008080; // Ped is missing | HV is missing | killed
+
fChargeSigmaCut = 4.0;
}
{
charge = fDigitCalibrator->CalibrateDigit(detElemId, manuId, manuChannel,adc,3.0);
}
+ else
+ {
+ charge = 0.0;
+ }
}
if (charge > 0.0 )
store = AliMUONCalibrationData::CreatePedestals(runNumber,&startOfValidity);
fData = CreateDataPedestals(startOfValidity);
}
+ else if ( stype == "KILLMAP" )
+ {
+ store = AliMUONCalibrationData::CreateKillMap(runNumber,&startOfValidity);
+ fData = CreateDataKillMap(startOfValidity);
+ }
else if ( stype == "GAINS" )
{
AliMUONVStore* gains = AliMUONCalibrationData::CreateGains(runNumber,&startOfValidity);
return data;
}
+//_____________________________________________________________________________
+AliMUONVTrackerData*
+AliMUONTrackerOCDBDataMaker::CreateDataKillMap(Int_t runNumber)
+{
+ /// Create data to hold pedestal values
+
+ AliMUONVTrackerData* data = new AliMUONTrackerData(Form("KILL%d",runNumber),"KillMap",1,kTRUE);
+ data->SetDimensionName(0,"Kill");
+ return data;
+}
+
//_____________________________________________________________________________
AliMUONVStore*
AliMUONTrackerOCDBDataMaker::CreateHVStore(TMap& m)
static AliMUONVStore* SplitQuality(const AliMUONVStore& gains);
static AliMUONVTrackerData* CreateDataPedestals(Int_t runNumber);
+ static AliMUONVTrackerData* CreateDataKillMap(Int_t runNumber);
static AliMUONVTrackerData* CreateDataGains(Int_t runNumber);
static AliMUONVTrackerData* CreateDataCapacitances(Int_t runNumber);