diff --git a/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt b/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
index 2adaa9bcf24f2..62fc09ffcad00 100644
--- a/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
+++ b/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
@@ -28,6 +28,7 @@ o2_target_root_dictionary(DataFormatsITSMFT
                                  include/DataFormatsITSMFT/Digit.h
                                  include/DataFormatsITSMFT/GBTCalibData.h
                                  include/DataFormatsITSMFT/NoiseMap.h
+                                 include/DataFormatsITSMFT/TimeDeadMap.h
                                   include/DataFormatsITSMFT/Cluster.h
                                   include/DataFormatsITSMFT/CompCluster.h
                                   include/DataFormatsITSMFT/ClusterPattern.h
diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h
index 4815b688ee7c1..ba98bf2e1e101 100644
--- a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h
@@ -170,6 +170,7 @@ class NoiseMap
   void print();
   void fill(const gsl::span<const CompClusterExt> data);
   void merge(const NoiseMap* prev) {}
+
   const std::map<int, int>* getChipMap(int chip) const { return chip < (int)mNoisyPixels.size() ? &mNoisyPixels[chip] : nullptr; }
 
   std::map<int, int>& getChip(int chip) { return mNoisyPixels[chip]; }
diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
new file mode 100644
index 0000000000000..2dfd22f9ddfd0
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
@@ -0,0 +1,160 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TimeDeadMap.h
+/// \brief Definition of the ITSMFT time-dependend dead map
+#ifndef ALICEO2_ITSMFT_TIMEDEADMAP_H
+#define ALICEO2_ITSMFT_TIMEDEADMAP_H
+
+#include "Rtypes.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include <iostream>
+#include <vector>
+#include <map>
+
+namespace o2
+{
+
+namespace itsmft
+{
+
+class TimeDeadMap
+{
+ public:
+  // Constructor
+  TimeDeadMap(std::map<unsigned long, std::vector<uint16_t>>& deadmap)
+  {
+    mEvolvingDeadMap.swap(deadmap);
+  }
+
+  /// Constructor
+  TimeDeadMap() = default;
+  /// Destructor
+  ~TimeDeadMap() = default;
+
+  void fillMap(unsigned long firstOrbit, const std::vector<uint16_t>& deadVect)
+  {
+    mEvolvingDeadMap[firstOrbit] = deadVect;
+  };
+
+  void fillMap(const std::vector<uint16_t>& deadVect)
+  {
+    mStaticDeadMap = deadVect;
+  }
+
+  void clear()
+  {
+    mEvolvingDeadMap.clear();
+    mStaticDeadMap.clear();
+  }
+
+  void decodeMap(o2::itsmft::NoiseMap& noisemap)
+  { // for static part only
+    if (mMAP_VERSION != "3") {
+      LOG(error) << "Trying to decode static part of deadmap version " << mMAP_VERSION << ". Not implemented, doing nothing.";
+      return;
+    }
+    for (int iel = 0; iel < mStaticDeadMap.size(); iel++) {
+      uint16_t w = mStaticDeadMap[iel];
+      noisemap.maskFullChip(w & 0x7FFF);
+      if (w & 0x8000) {
+        for (int w2 = (w & 0x7FFF) + 1; w2 < mStaticDeadMap.at(iel + 1); w2++) {
+          noisemap.maskFullChip(w2);
+        }
+      }
+    }
+  }
+
+  void decodeMap(unsigned long orbit, o2::itsmft::NoiseMap& noisemap, bool includeStaticMap = true)
+  { // for time-dependent and (optionally) static part
+
+    if (mMAP_VERSION != "3" && mMAP_VERSION != "4") {
+      LOG(error) << "Trying to decode time-dependent deadmap version " << mMAP_VERSION << ". Not implemented, doing nothing.";
+      return;
+    }
+
+    if (mEvolvingDeadMap.empty()) {
+      LOG(warning) << "Time-dependent dead map is empty. Doing nothing.";
+      return;
+    } else if (orbit > mEvolvingDeadMap.rbegin()->first + 11000 * 300 || orbit < mEvolvingDeadMap.begin()->first - 11000 * 300) {
+      // the map should not leave several minutes uncovered.
+      LOG(warning) << "Time-dependent dead map: the requested orbit " << orbit << " seems to be out of the range stored in the map.";
+    }
+
+    std::vector<uint16_t> closestVec;
+    long dT = getMapAtOrbit(orbit, closestVec);
+
+    // add static part if requested. something may be masked twice
+    if (includeStaticMap && mMAP_VERSION != "3") {
+      closestVec.insert(closestVec.end(), mStaticDeadMap.begin(), mStaticDeadMap.end());
+    }
+
+    // vector encoding: if 1<<15 = 0x8000 is set, the word encodes the first element of a range, with mask (1<<15)-1 = 0x7FFF. The last element of the range is the next in the vector.
+
+    for (int iel = 0; iel < closestVec.size(); iel++) {
+      uint16_t w = closestVec.at(iel);
+      noisemap.maskFullChip(w & 0x7FFF);
+      if (w & 0x8000) {
+        for (int w2 = (w & 0x7FFF) + 1; w2 < closestVec.at(iel + 1); w2++) {
+          noisemap.maskFullChip(w2);
+        }
+      }
+    }
+  };
+
+  std::string getMapVersion() const { return mMAP_VERSION; };
+
+  unsigned long getEvolvingMapSize() const { return mEvolvingDeadMap.size(); };
+
+  std::vector<unsigned long> getEvolvingMapKeys()
+  {
+    std::vector<unsigned long> keys;
+    std::transform(mEvolvingDeadMap.begin(), mEvolvingDeadMap.end(), std::back_inserter(keys),
+                   [](const auto& O) { return O.first; });
+    return keys;
+  }
+
+  void getStaticMap(std::vector<uint16_t>& mmap) { mmap = mStaticDeadMap; };
+
+  long getMapAtOrbit(unsigned long orbit, std::vector<uint16_t>& mmap)
+  { // fills mmap and returns orbit - lower_bound
+    if (mEvolvingDeadMap.empty()) {
+      LOG(warning) << "Requested orbit " << orbit << "from an empty time-dependent map. Doing nothing";
+      return (long)orbit;
+    }
+    auto closest = mEvolvingDeadMap.lower_bound(orbit);
+    if (closest != mEvolvingDeadMap.end()) {
+      mmap = closest->second;
+      return (long)orbit - closest->first;
+    } else {
+      mmap = mEvolvingDeadMap.rbegin()->second;
+      return (long)(orbit)-mEvolvingDeadMap.rbegin()->first;
+    }
+  }
+
+  void setMapVersion(std::string version) { mMAP_VERSION = version; };
+
+  bool isDefault() { return mIsDefaultObject; };
+  void setAsDefault(bool isdef = true) { mIsDefaultObject = isdef; };
+
+ private:
+  bool mIsDefaultObject = false;
+  std::string mMAP_VERSION = "3";
+  std::map<unsigned long, std::vector<uint16_t>> mEvolvingDeadMap; ///< Internal dead chip map representation. key = orbit
+  std::vector<uint16_t> mStaticDeadMap;                            ///< To store map valid for every orbit. Filled starting from version = 4.
+
+  ClassDefNV(TimeDeadMap, 2);
+};
+
+} // namespace itsmft
+} // namespace o2
+
+#endif /* ALICEO2_ITSMFT_TIMEDEADMAP_H */
diff --git a/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h b/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h
index 80fc3a1b3f70a..fc67fdf028436 100644
--- a/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h
+++ b/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h
@@ -17,6 +17,7 @@
 
 #pragma link C++ class o2::itsmft::Digit + ;
 #pragma link C++ class o2::itsmft::NoiseMap + ;
+#pragma link C++ class o2::itsmft::TimeDeadMap + ;
 #pragma link C++ class std::vector < o2::itsmft::Digit> + ;
 
 #pragma link C++ class o2::itsmft::GBTCalibData + ;
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
index 3a5b9587df1a0..e3e16f15586ee 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
@@ -111,8 +111,8 @@ class Digitizer : public TObject
 
   static constexpr float sec2ns = 1e9;
 
-  o2::itsmft::DigiParams mParams; ///< digitization parameters
-  o2::InteractionTimeRecord mEventTime; ///< global event time and interaction record
+  o2::itsmft::DigiParams mParams;          ///< digitization parameters
+  o2::InteractionTimeRecord mEventTime;    ///< global event time and interaction record
   o2::InteractionRecord mIRFirstSampledTF; ///< IR of the 1st sampled IR, noise-only ROFs will be inserted till this IR only
   double mCollisionTimeWrtROF;
   uint32_t mROFrameMin = 0; ///< lowest RO frame of current digits
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DeadMapBuilderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DeadMapBuilderSpec.h
index 35e3a5bc422c9..1298656713cb0 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DeadMapBuilderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DeadMapBuilderSpec.h
@@ -42,6 +42,7 @@
 #include <fairmq/Device.h>
 
 #include <ITSMFTReconstruction/RawPixelDecoder.h> //o2::itsmft::RawPixelDecoder
+#include "DataFormatsITSMFT/TimeDeadMap.h"
 #include "DetectorsCalibration/Utils.h"
 #include "DetectorsCommonDataFormats/FileMetaData.h"
 #include "DetectorsBase/GRPGeomHelper.h"
@@ -91,7 +92,7 @@ class ITSMFTDeadMapBuilder : public Task
   std::string mObjectName;
   std::string mLocalOutputDir;
 
-  std::string MAP_VERSION = "2"; // to change in case the encoding or the format change
+  std::string MAP_VERSION = "3"; // to change in case the encoding or the format change
 
   std::vector<uint16_t> mDeadMapTF{};
 
@@ -101,14 +102,14 @@ class ITSMFTDeadMapBuilder : public Task
 
   int mTFSampling = 1000;
 
-  std::map<unsigned long, std::vector<uint16_t>> mMapObject{};
+  o2::itsmft::TimeDeadMap mMapObject;
 
   void finalizeOutput();
   void PrepareOutputCcdb(DataAllocator& output);
 
   // Utils
 
-  uint16_t getElementIDFromChip(uint16_t);
+  std::vector<uint16_t> getChipIDsOnSameCable(uint16_t);
 
   o2::framework::DataTakingContext mDataTakingContext{};
   o2::framework::TimingInfo mTimingInfo{};
diff --git a/Detectors/ITSMFT/common/workflow/src/DeadMapBuilderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DeadMapBuilderSpec.cxx
index ed50ed91c98e3..fd14c926da706 100644
--- a/Detectors/ITSMFT/common/workflow/src/DeadMapBuilderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DeadMapBuilderSpec.cxx
@@ -16,6 +16,7 @@
 #include "CCDB/BasicCCDBManager.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/TimeDeadMap.h"
 
 namespace o2
 {
@@ -54,6 +55,7 @@ void ITSMFTDeadMapBuilder::init(InitContext& ic)
   mDeadMapTF.clear();
 
   mMapObject.clear();
+  mMapObject.setMapVersion(MAP_VERSION);
 
   mTFSampling = ic.options().get<int>("tf-sampling");
   mTFLength = ic.options().get<int>("tf-length");
@@ -66,21 +68,17 @@ void ITSMFTDeadMapBuilder::init(InitContext& ic)
   return;
 }
 
-//////////////////////////////////////////////////////////////////////////////
-uint16_t ITSMFTDeadMapBuilder::getElementIDFromChip(uint16_t chip)
+///////////////////////////////////////////////////////////////////
+// TODO: can ChipMappingITS help here?
+std::vector<uint16_t> ITSMFTDeadMapBuilder::getChipIDsOnSameCable(uint16_t chip)
 {
-  // MFT - no grouping
-  if (mRunMFT) {
-    return (uint16_t)chip;
-  }
-  // ITS - group chips into lanes
-  // TODO: does o2::itsmft::ChipMappingITS already contain this?
-  else {
-    if (chip < N_CHIPS_ITSIB) {
-      return (uint16_t)chip;
-    } else {
-      return N_CHIPS_ITSIB + (uint16_t)((chip - N_CHIPS_ITSIB) / 7);
-    }
+  if (mRunMFT || chip < N_CHIPS_ITSIB) {
+    return std::vector<uint16_t>{chip};
+  } else {
+    uint16_t firstchipcable = 7 * (uint16_t)((chip - N_CHIPS_ITSIB) / 7) + N_CHIPS_ITSIB;
+    std::vector<uint16_t> chipList(7);
+    std::generate(chipList.begin(), chipList.end(), [&firstchipcable]() { return firstchipcable++; });
+    return chipList;
   }
 }
 
@@ -92,7 +90,7 @@ void ITSMFTDeadMapBuilder::finalizeOutput()
   if (mDoLocalOutput) {
     std::string localoutfilename = mLocalOutputDir + "/" + mObjectName;
     TFile outfile(localoutfilename.c_str(), "RECREATE");
-    outfile.WriteObjectAny(&mMapObject, "std::map<unsigned long, std::vector<uint16_t>>", "ccdb_object");
+    outfile.WriteObjectAny(&mMapObject, "o2::itsmft::TimeDeadMap", "ccdb_object");
     outfile.Close();
   }
   return;
@@ -124,7 +122,7 @@ void ITSMFTDeadMapBuilder::run(ProcessingContext& pc)
 
   mDeadMapTF.clear();
 
-  std::vector<bool> ElementsStatus(getElementIDFromChip(N_CHIPS), false);
+  std::vector<bool> ChipStatus(N_CHIPS, false);
 
   if (mDataSource == "digits") {
     const auto elements = pc.inputs().get<gsl::span<o2::itsmft::Digit>>("elements");
@@ -132,8 +130,7 @@ void ITSMFTDeadMapBuilder::run(ProcessingContext& pc)
     for (const auto& rof : ROFs) {
       auto elementsInTF = rof.getROFData(elements);
       for (const auto& el : elementsInTF) {
-        uint16_t chipID = (uint16_t)el.getChipIndex();
-        ElementsStatus.at(getElementIDFromChip(chipID)) = true;
+        ChipStatus.at((int)el.getChipIndex()) = true;
       }
     }
   } else if (mDataSource == "clusters") {
@@ -142,28 +139,40 @@ void ITSMFTDeadMapBuilder::run(ProcessingContext& pc)
     for (const auto& rof : ROFs) {
       auto elementsInTF = rof.getROFData(elements);
       for (const auto& el : elementsInTF) {
-        uint16_t chipID = (uint16_t)el.getSensorID();
-        ElementsStatus.at(getElementIDFromChip(chipID)) = true;
+        ChipStatus.at((int)el.getSensorID()) = true;
       }
     }
   } else if (mDataSource == "chipsstatus") {
     const auto elements = pc.inputs().get<gsl::span<char>>("elements");
     for (uint16_t chipID = 0; chipID < elements.size(); chipID++) {
       if (elements[chipID]) {
-        ElementsStatus.at(getElementIDFromChip(chipID)) = true;
+        ChipStatus.at(chipID) = true;
+      }
+    }
+  }
+
+  // for ITS, declaring dead only chips belonging to lane with no hits
+  if (!mRunMFT) {
+    for (uint16_t el = N_CHIPS_ITSIB; el < ChipStatus.size(); el++) {
+      if (ChipStatus.at(el)) {
+        std::vector<uint16_t> chipincable = getChipIDsOnSameCable(el);
+        for (uint16_t el2 : chipincable) {
+          ChipStatus.at(el2) = true;
+          el = el2;
+        }
       }
     }
   }
 
   int CountDead = 0;
 
-  for (uint16_t el = 0; el < ElementsStatus.size(); el++) {
-    if (ElementsStatus.at(el)) {
+  for (uint16_t el = 0; el < ChipStatus.size(); el++) {
+    if (ChipStatus.at(el)) {
       continue;
     }
     CountDead++;
-    bool previous_dead = (el > 0 && !ElementsStatus.at(el - 1));
-    bool next_dead = (el < ElementsStatus.size() - 1 && !ElementsStatus.at(el + 1));
+    bool previous_dead = (el > 0 && !ChipStatus.at(el - 1));
+    bool next_dead = (el < ChipStatus.size() - 1 && !ChipStatus.at(el + 1));
     if (!previous_dead && next_dead) {
       mDeadMapTF.push_back(el | (uint16_t)(0x8000));
     } else if (previous_dead && next_dead) {
@@ -173,10 +182,10 @@ void ITSMFTDeadMapBuilder::run(ProcessingContext& pc)
     }
   }
 
-  LOG(info) << "TF contains " << CountDead << " dead elements, saved into " << mDeadMapTF.size() << " words.";
+  LOG(info) << "TF contains " << CountDead << " dead chips, saved into " << mDeadMapTF.size() << " words.";
 
   // filling the map
-  mMapObject[mFirstOrbitTF] = mDeadMapTF;
+  mMapObject.fillMap(mFirstOrbitTF, mDeadMapTF);
 
   end = std::chrono::high_resolution_clock::now();
   int difference = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
@@ -197,10 +206,10 @@ void ITSMFTDeadMapBuilder::PrepareOutputCcdb(DataAllocator& output)
   std::map<std::string, std::string> md = {
     {"map_version", MAP_VERSION}};
 
-  std::string path = mRunMFT ? "MFT/Calib" : "ITS/Calib/";
-  std::string name_str = "time_dead_map";
+  std::string path = mRunMFT ? "MFT/Calib/" : "ITS/Calib/";
+  std::string name_str = "TimeDeadMap";
 
-  o2::ccdb::CcdbObjectInfo info((path + name_str), "time_dead_map", mObjectName, md, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info((path + name_str), name_str, mObjectName, md, tstart, tend);
 
   auto image = o2::ccdb::CcdbApi::createObjectImage(&mMapObject, &info);
   info.setFileName(mObjectName);
@@ -212,11 +221,11 @@ void ITSMFTDeadMapBuilder::PrepareOutputCcdb(DataAllocator& output)
             << info.getStartValidityTimestamp() << " : " << info.getEndValidityTimestamp();
 
   if (mRunMFT) {
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "MFT_TimeDeadMap", 0}, *image.get());
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "MFT_TimeDeadMap", 0}, info);
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "TimeDeadMap", 1}, *image.get());
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "TimeDeadMap", 1}, info);
   } else {
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "ITS_TimeDeadMap", 0}, *image.get());
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "ITS_TimeDeadMap", 0}, info);
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "TimeDeadMap", 0}, *image.get());
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "TimeDeadMap", 0}, info);
   }
 
   return;
@@ -278,13 +287,8 @@ DataProcessorSpec getITSMFTDeadMapBuilderSpec(std::string datasource, bool doMFT
   }
 
   std::vector<OutputSpec> outputs;
-  if (doMFT) {
-    outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "MFT_TimeDeadMap"}, Lifetime::Sporadic);
-    outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "MFT_TimeDeadMap"}, Lifetime::Sporadic);
-  } else {
-    outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "ITS_TimeDeadMap"}, Lifetime::Sporadic);
-    outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "ITS_TimeDeadMap"}, Lifetime::Sporadic);
-  }
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "TimeDeadMap"}, Lifetime::Sporadic);
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "TimeDeadMap"}, Lifetime::Sporadic);
 
   std::string detector = doMFT ? "mft" : "its";
   std::string objectname_default = detector + "_time_deadmap.root";
diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
index 2a8c28bb4dbbd..f6c8c1e1d1a48 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
@@ -20,6 +20,7 @@
 #include "Steer/HitProcessingManager.h" // for DigitizationContext
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/NoiseMap.h"
+#include "DataFormatsITSMFT/TimeDeadMap.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "DetectorsBase/BaseDPLDigitizer.h"
 #include "DetectorsCommonDataFormats/DetID.h"
@@ -61,6 +62,7 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     }
     mID == o2::detectors::DetID::ITS ? updateTimeDependentParams<o2::detectors::DetID::ITS>(pc) : updateTimeDependentParams<o2::detectors::DetID::MFT>(pc);
     std::string detStr = mID.getName();
+    mFirstOrbitTF = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
     // read collision context from input
     auto context = pc.inputs().get<o2::steer::DigitizationContext*>("collisioncontext");
     context->initSimChains(mID, mSimChains);
@@ -189,8 +191,26 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
       return;
     }
     if (matcher == ConcreteDataMatcher(mOrigin, "DEADMAP", 0)) {
-      LOG(info) << mID.getName() << " dead map updated";
-      mDigitizer.setDeadChannelsMap((const o2::itsmft::NoiseMap*)obj);
+      LOG(info) << mID.getName() << " static dead map updated";
+      mDeadMap = (o2::itsmft::NoiseMap*)obj;
+      mDigitizer.setDeadChannelsMap(mDeadMap);
+      return;
+    }
+    if (matcher == ConcreteDataMatcher(mOrigin, "TimeDeadMap", 0)) {
+      o2::itsmft::TimeDeadMap* timedeadmap = (o2::itsmft::TimeDeadMap*)obj;
+      if (!timedeadmap->isDefault()) {
+        timedeadmap->decodeMap(mFirstOrbitTF, *mDeadMap, true);
+        static bool UpdateDone = false;
+        if (UpdateDone) {
+          LOGP(fatal, "Attempt to add time-dependent map to already modified static map");
+        }
+        UpdateDone = true;
+        mDigitizer.setDeadChannelsMap(mDeadMap);
+        LOG(info) << mID.getName() << " time-dependent dead map updated";
+      } else {
+        LOG(info) << mID.getName() << " time-dependent dead map is default/empty";
+      }
+
       return;
     }
     if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDEPARAM", 0)) {
@@ -215,6 +235,8 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     std::string detstr(o2::detectors::DetID::getName(DETID));
     pc.inputs().get<o2::itsmft::NoiseMap*>(detstr + "_noise");
     pc.inputs().get<o2::itsmft::NoiseMap*>(detstr + "_dead");
+    // TODO: the code should run even if this object does not exist. Or: create default object
+    pc.inputs().get<o2::itsmft::TimeDeadMap*>(detstr + "_time_dead");
     pc.inputs().get<o2::itsmft::DPLAlpideParam<DETID>*>(detstr + "_alppar");
 
     auto& dopt = o2::itsmft::DPLDigitizerParam<DETID>::Instance();
@@ -263,6 +285,7 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
   bool mWithMCTruth = true;
   bool mFinished = false;
   bool mDisableQED = false;
+  unsigned long mFirstOrbitTF = 0x0;
   o2::detectors::DetID mID;
   o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
   o2::itsmft::Digitizer mDigitizer;
@@ -275,6 +298,7 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
   o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabelsAccum;
   std::vector<o2::itsmft::MC2ROFRecord> mMC2ROFRecordsAccum;
   std::vector<TChain*> mSimChains;
+  o2::itsmft::NoiseMap* mDeadMap = nullptr;
 
   int mFixMC2ROF = 0;                                                             // 1st entry in mc2rofRecordsAccum to be fixed for ROFRecordID
   o2::parameters::GRPObject::ROMode mROMode = o2::parameters::GRPObject::PRESENT; // readout mode
@@ -340,6 +364,7 @@ DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
   inputs.emplace_back("ITS_noise", "ITS", "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/NoiseMap"));
   inputs.emplace_back("ITS_dead", "ITS", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/DeadMap"));
+  inputs.emplace_back("ITS_time_dead", "ITS", "TimeDeadMap", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/TimeDeadMap"));
   inputs.emplace_back("ITS_alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
 
   return DataProcessorSpec{(detStr + "Digitizer").c_str(),
@@ -358,6 +383,7 @@ DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
   inputs.emplace_back("MFT_noise", "MFT", "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/NoiseMap"));
   inputs.emplace_back("MFT_dead", "MFT", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/DeadMap"));
+  inputs.emplace_back("MFT_time_dead", "MFT", "TimeDeadMap", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/TimeDeadMap"));
   inputs.emplace_back("MFT_alppar", "MFT", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("MFT/Config/AlpideParam"));
   parHelper << "Params as " << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
             << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::Instance()
diff --git a/Steer/src/SteerLinkDef.h b/Steer/src/SteerLinkDef.h
index e534489d8c316..9d83dc5561ca1 100644
--- a/Steer/src/SteerLinkDef.h
+++ b/Steer/src/SteerLinkDef.h
@@ -20,6 +20,6 @@
 #pragma link C++ class o2::steer::O2MCApplicationEvalMat + ;
 #pragma link C++ class o2::steer::O2MCApplication + ;
 #pragma link C++ class o2::steer::MCKinematicsReader + ;
-#pragma link C++ class o2::steer::MaterialBudgetMap +
+#pragma link C++ class o2::steer::MaterialBudgetMap + ;
 
 #endif