Introducing a new OCDB object, MUON/Calib/KillMap, which allows to selectively

kill some tracker channels, based on initial analysis of the data.
(Laurent)

diff --git a/MUON/AliMUONCDB.cxx b/MUON/AliMUONCDB.cxx
index 02f750b2a386587f66aeb2f9116a9939c27da415..2f50e4b6659dce2d63785b863cceeebb3fb4d9b7 100644 (file)
--- a/MUON/AliMUONCDB.cxx
+++ b/MUON/AliMUONCDB.cxx
@@ -531,6 +531,60 @@ AliMUONCDB::MakePedestalStore(AliMUONVStore& pedestalStore, Bool_t defaultValues
   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)
@@ -1063,6 +1117,26 @@ AliMUONCDB::WritePedestals(Bool_t 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 
@@ -1140,5 +1214,6 @@ AliMUONCDB::WriteTracker(Bool_t defaultValues, Int_t startRun, Int_t endRun)
   WriteGains(defaultValues,startRun,endRun);
   WriteCapacitances(defaultValues,startRun,endRun);
   WriteNeighbours(startRun,endRun);
+  WriteKillMap(startRun,endRun,defaultValues);
 }
 

diff --git a/MUON/AliMUONCDB.h b/MUON/AliMUONCDB.h
index 5de34d6c07370a715923a8e574c2569504c40d64..f5e4edbe3da2f823748cbcd7f4119f9825580cd0 100644 (file)
--- a/MUON/AliMUONCDB.h
+++ b/MUON/AliMUONCDB.h
@@ -41,6 +41,7 @@ public:
   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;
@@ -72,6 +73,7 @@ public:
   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());

diff --git a/MUON/AliMUONCalibrationData.cxx b/MUON/AliMUONCalibrationData.cxx
index 07dff516fb04368efe31af8954fd63a5ea41fa64..b0306eb433fc4fd1502bc092df1c519bdee3207c 100644 (file)
--- a/MUON/AliMUONCalibrationData.cxx
+++ b/MUON/AliMUONCalibrationData.cxx
@@ -69,7 +69,8 @@ fGlobalTriggerCrateConfig(0x0),
 fTriggerLut(0x0),
 fTriggerEfficiency(0x0),
 fCapacitances(0x0),
-fNeighbours(0x0)
+fNeighbours(0x0),
+fKillMap(0x0)
 {
 /// Default ctor.
 
@@ -83,6 +84,7 @@ fNeighbours(0x0)
   {
     Gains();
     Pedestals();
+    KillMap();
     HV();
     TriggerDCS();
     LocalTriggerBoardMasks(0);
@@ -207,6 +209,14 @@ AliMUONCalibrationData::CreateObject(Int_t runNumber, const char* path, Int_t* s
   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)
@@ -348,6 +358,36 @@ AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
   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

diff --git a/MUON/AliMUONCalibrationData.h b/MUON/AliMUONCalibrationData.h
index 8bb1778b9b051dbba2de131485287dfaec94f080..d06d84b35a9bf3dd3cdc2bc28962099a23d690b7 100644 (file)
--- a/MUON/AliMUONCalibrationData.h
+++ b/MUON/AliMUONCalibrationData.h
@@ -60,6 +60,9 @@ public:
   /// 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);
 
@@ -97,7 +100,13 @@ public:
   
   /// 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;
   
@@ -145,7 +154,9 @@ private:
   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

diff --git a/MUON/AliMUONPadStatusMaker.cxx b/MUON/AliMUONPadStatusMaker.cxx
index 6e038b223fe0cfccd3156660fcf1e4012f7a20bd..a6bc3758f1c5570f374c3c8866697e543ca6d0b4 100644 (file)
--- a/MUON/AliMUONPadStatusMaker.cxx
+++ b/MUON/AliMUONPadStatusMaker.cxx
@@ -80,7 +80,8 @@ fStatus(new AliMUON2DMap(true)),
 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",
@@ -153,6 +154,7 @@ AliMUONPadStatusMaker::~AliMUONPadStatusMaker()
   /// dtor.
   delete fStatus;
   delete fHV;
+  delete fKillMap;
 }
 
 //_____________________________________________________________________________
@@ -194,6 +196,7 @@ AliMUONPadStatusMaker::AsString(Int_t status)
 
   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] = ' ';
   
@@ -526,6 +529,13 @@ AliMUONPadStatusMaker::ComputeStatus(Int_t detElemId, Int_t manuId) const
 
   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);
@@ -568,6 +578,11 @@ AliMUONPadStatusMaker::ComputeStatus(Int_t detElemId, Int_t manuId) const
     {
       gainStatus = kGainMissing;
     }
+    
+    if ( kill && (kill->ValueAsInt(manuChannel,0) > 0) ) 
+    {
+      otherStatus |= kKilled;
+    }
         
     Int_t status = BuildStatus(pedStatus,hvStatus,gainStatus,otherStatus);
       

diff --git a/MUON/AliMUONPadStatusMaker.h b/MUON/AliMUONPadStatusMaker.h
index ef626ab3924798cd599bd17ee8cb1a74290fc349..859bc390adbabafad0a1324813438f89a78a9252 100644 (file)
--- a/MUON/AliMUONPadStatusMaker.h
+++ b/MUON/AliMUONPadStatusMaker.h
@@ -177,7 +177,8 @@ private:
   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)
@@ -203,6 +204,8 @@ private:
   
   AliMUONVTrackerData* fTrackerData; //!< to get occupancies...
   
+  AliMUONVStore* fKillMap; //!< to selectively force killing of some channels
+  
   ClassDef(AliMUONPadStatusMaker,0) // Creates pad statuses from ped,gain,hv
 };
 

diff --git a/MUON/AliMUONPainterDataSourceFrame.cxx b/MUON/AliMUONPainterDataSourceFrame.cxx
index 245cf21ce156899b6790c31abbc8360a64ca1d92..c3105ed111ce9445b266dfd3013fc142e05db80f 100644 (file)
--- a/MUON/AliMUONPainterDataSourceFrame.cxx
+++ b/MUON/AliMUONPainterDataSourceFrame.cxx
@@ -174,7 +174,8 @@ AliMUONPainterDataSourceFrame::AliMUONPainterDataSourceFrame(const TGWindow* p,
     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);
     
@@ -205,7 +206,9 @@ AliMUONPainterDataSourceFrame::AliMUONPainterDataSourceFrame(const TGWindow* p,
     
     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);
     

diff --git a/MUON/AliMUONRecoParam.cxx b/MUON/AliMUONRecoParam.cxx
index d7840a74bb1acaa85f22cb40767f3460ad2d698a..714742fc8b6146583ce49ae902b46edcf4987b9f 100644 (file)
--- a/MUON/AliMUONRecoParam.cxx
+++ b/MUON/AliMUONRecoParam.cxx
@@ -270,7 +270,7 @@ void AliMUONRecoParam::SetCosmicParam()
   }
   for (Int_t iSt = 0; iSt < 5; iSt++) fRequestStation[iSt] = kTRUE;
   fBypassSt45 = 0;
-  fPadGoodnessMask = 0x400BE80;
+  fPadGoodnessMask = 0xC00BE80;
   fMaxTriggerTracks = 100;
   fMaxTrackCandidates = 10000;
   
@@ -480,7 +480,8 @@ AliMUONRecoParam::SetDefaultLimits()
        fGainThresLimits[0] = 0;
        fGainThresLimits[1] = 4095;
        
-       fPadGoodnessMask = 0x8080;
+       fPadGoodnessMask = 0x8008080; // Ped is missing | HV is missing | killed
+
   
   fChargeSigmaCut = 4.0;
 }

diff --git a/MUON/AliMUONTrackerDataMaker.cxx b/MUON/AliMUONTrackerDataMaker.cxx
index ebb16f0963aee266c71e77810922b4e0bd6cac09..827e32f4f4fc10bd99896328380661298b7beffd 100644 (file)
--- a/MUON/AliMUONTrackerDataMaker.cxx
+++ b/MUON/AliMUONTrackerDataMaker.cxx
@@ -379,6 +379,10 @@ Bool_t AliMUONTrackerDataMaker::ProcessEvent()
       {
         charge = fDigitCalibrator->CalibrateDigit(detElemId, manuId, manuChannel,adc,3.0);
       }
+      else
+      {
+        charge = 0.0;
+      }
     }
     
     if (charge > 0.0 ) 

diff --git a/MUON/AliMUONTrackerOCDBDataMaker.cxx b/MUON/AliMUONTrackerOCDBDataMaker.cxx
index 54ce05f726005323b6fb5a6c886ff66fbf35e446..1eb440569a37e3edc19c570cf9750a5883513197 100644 (file)
--- a/MUON/AliMUONTrackerOCDBDataMaker.cxx
+++ b/MUON/AliMUONTrackerOCDBDataMaker.cxx
@@ -73,6 +73,11 @@ AliMUONTrackerOCDBDataMaker::AliMUONTrackerOCDBDataMaker(const char* ocdbPath,
                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);
@@ -157,6 +162,17 @@ AliMUONTrackerOCDBDataMaker::CreateDataPedestals(Int_t runNumber)
   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)

diff --git a/MUON/AliMUONTrackerOCDBDataMaker.h b/MUON/AliMUONTrackerOCDBDataMaker.h
index 18b6354427aec9856b8fc2cff7f2fb10e5d919ab..029bfe263655e8fcecd739c807248ad5b0bb6327 100644 (file)
--- a/MUON/AliMUONTrackerOCDBDataMaker.h
+++ b/MUON/AliMUONTrackerOCDBDataMaker.h
@@ -66,6 +66,7 @@ public:
   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);
   

diff --git a/OCDB/MUON/Calib/KillMap/Run0_999999999_v0_s0.root b/OCDB/MUON/Calib/KillMap/Run0_999999999_v0_s0.root
new file mode 100644 (file)
index 0000000..e40befa
Binary files /dev/null and b/OCDB/MUON/Calib/KillMap/Run0_999999999_v0_s0.root differ