Switch all detector raw input lifetimes from optional to time frame

davidrohr · davidrohr · commit 42bd8bab5537 · 2023-11-10T15:47:14.000+01:00
diff --git a/Detectors/CPV/workflow/src/RawToDigitConverterSpec.cxx b/Detectors/CPV/workflow/src/RawToDigitConverterSpec.cxx
@@ -313,7 +313,7 @@ void RawToDigitConverterSpec::run(framework::ProcessingContext& ctx)
 o2::framework::DataProcessorSpec o2::cpv::reco_workflow::getRawToDigitConverterSpec(bool askDISTSTF, bool isPedestal, bool useBadChannelMap, bool useGainCalibration)
 {
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("RAWDATA", o2::framework::ConcreteDataTypeMatcher{"CPV", "RAWDATA"}, o2::framework::Lifetime::Optional);
+  inputs.emplace_back("RAWDATA", o2::framework::ConcreteDataTypeMatcher{"CPV", "RAWDATA"}, o2::framework::Lifetime::Timeframe);
   // receive at least 1 guaranteed input (which will allow to acknowledge the TF)
   if (askDISTSTF) {
     inputs.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
diff --git a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
@@ -166,7 +166,7 @@ o2::framework::DataProcessorSpec o2::ctp::reco_workflow::getRawDecoderSpec(bool
     throw std::runtime_error("all outputs were disabled");
   }
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"CTP", "RAWDATA"}, o2::framework::Lifetime::Optional);
+  inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"CTP", "RAWDATA"}, o2::framework::Lifetime::Timeframe);
   if (askDISTSTF) {
     inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
   }
diff --git a/Detectors/EMCAL/workflow/src/RawToCellConverterSpec.cxx b/Detectors/EMCAL/workflow/src/RawToCellConverterSpec.cxx
@@ -750,7 +750,7 @@ o2::framework::DataProcessorSpec o2::emcal::reco_workflow::getRawToCellConverter
     outputs.emplace_back(originEMC, "DECODERERR", subspecification, o2::framework::Lifetime::Timeframe);
   }
 
-  std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originEMC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Optional}};
+  std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originEMC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Timeframe}};
   if (askDISTSTF) {
     inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
   }
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataDecoderDPLSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataDecoderDPLSpec.h
@@ -110,7 +110,7 @@ framework::DataProcessorSpec getFT0DataDecoderDPLSpec(bool askSTFDist)
   std::vector<OutputSpec> outputSpec;
   outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSBC", 0, Lifetime::Timeframe);
   outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSCH", 0, Lifetime::Timeframe);
-  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{"FT0", "RAWDATA"}, Lifetime::Optional}};
+  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{"FT0", "RAWDATA"}, Lifetime::Timeframe}};
   if (askSTFDist) {
     inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
   }
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataReaderDPLSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataReaderDPLSpec.h
@@ -92,7 +92,7 @@ framework::DataProcessorSpec getFT0DataReaderDPLSpec(const RawReader& rawReader,
   LOG(info) << "DataProcessorSpec initDataProcSpec() for RawReaderFT0";
   std::vector<OutputSpec> outputSpec;
   RawReader::prepareOutputSpec(outputSpec);
-  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginFT0, "RAWDATA"}, Lifetime::Optional}};
+  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginFT0, "RAWDATA"}, Lifetime::Timeframe}};
   if (askSTFDist) {
     inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
   }
diff --git a/Detectors/FIT/workflow/include/FITWorkflow/FITDataReaderDPLSpec.h b/Detectors/FIT/workflow/include/FITWorkflow/FITDataReaderDPLSpec.h
@@ -175,7 +175,7 @@ framework::DataProcessorSpec getFITDataReaderDPLSpec(const RawReaderType& rawRea
     inputSpec.push_back({"STF", ConcreteDataTypeMatcher{rawReader.mDataOrigin, "SUB_RAWDATA"}, Lifetime::Sporadic}); // in case if one need to use DataSampler
     askSTFDist = false;
   } else {
-    inputSpec.push_back({"STF", ConcreteDataTypeMatcher{rawReader.mDataOrigin, "RAWDATA"}, Lifetime::Optional});
+    inputSpec.push_back({"STF", ConcreteDataTypeMatcher{rawReader.mDataOrigin, "RAWDATA"}, Lifetime::Timeframe});
   }
   if (askSTFDist) {
     inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
diff --git a/Detectors/FOCAL/workflow/src/RawDecoderSpec.cxx b/Detectors/FOCAL/workflow/src/RawDecoderSpec.cxx
@@ -675,7 +675,7 @@ o2::framework::DataProcessorSpec o2::focal::reco_workflow::getRawDecoderSpec(boo
   outputs.emplace_back(originFOC, "PIXELCHIPS", outputSubspec, o2::framework::Lifetime::Timeframe);
   outputs.emplace_back(originFOC, "TRIGGERS", outputSubspec, o2::framework::Lifetime::Timeframe);
 
-  std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originFOC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Optional}};
+  std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originFOC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Timeframe}};
   if (askDISTSTF) {
     inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
   }
diff --git a/Detectors/HMPID/workflow/src/DataDecoderSpec.cxx b/Detectors/HMPID/workflow/src/DataDecoderSpec.cxx
@@ -280,7 +280,7 @@ void DataDecoderTask::decodeRawFile(framework::ProcessingContext& pc)
 o2::framework::DataProcessorSpec getDecodingSpec(bool askDISTSTF)
 {
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Optional);
+  inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Timeframe);
   if (askDISTSTF) {
     inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
   }
diff --git a/Detectors/HMPID/workflow/src/DataDecoderSpec2.cxx b/Detectors/HMPID/workflow/src/DataDecoderSpec2.cxx
@@ -336,7 +336,7 @@ void DataDecoderTask2::orderTriggers()
 o2::framework::DataProcessorSpec getDecodingSpec2(bool askDISTSTF)
 {
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Optional);
+  inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Timeframe);
   if (askDISTSTF) {
     inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
   }
diff --git a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
@@ -356,9 +356,6 @@ DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)
   outputs.emplace_back(inp.origin, "ChipErrors", 0, Lifetime::Timeframe);
 
   if (inp.askSTFDist) {
-    for (auto& ins : inputs) { // mark input as optional in order not to block the workflow if our raw data happen to be missing in some TFs
-      ins.lifetime = Lifetime::Optional;
-    }
     // request the input FLP/DISTSUBTIMEFRAME/0 that is _guaranteed_ to be present, even if none of our raw data is present.
     inputs.emplace_back("stfDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
   }
diff --git a/Detectors/MUON/MCH/Workflow/src/DataDecoderSpec.cxx b/Detectors/MUON/MCH/Workflow/src/DataDecoderSpec.cxx
@@ -351,11 +351,6 @@ o2::framework::DataProcessorSpec getDecodingSpec(const char* specName, std::stri
                                                  bool askSTFDist)
 {
   auto inputs = o2::framework::select(inputSpec.c_str());
-  for (auto& inp : inputs) {
-    // mark input as optional in order not to block the workflow
-    // if our raw data happen to be missing in some TFs
-    inp.lifetime = Lifetime::Optional;
-  }
   if (askSTFDist) {
     // request the input FLP/DISTSUBTIMEFRAME/0 that is _guaranteed_
     // to be present, even if none of our raw data is present.
diff --git a/Detectors/MUON/MCH/Workflow/src/dump-pages-workflow.cxx b/Detectors/MUON/MCH/Workflow/src/dump-pages-workflow.cxx
@@ -106,11 +106,6 @@ class DumpPagesTask
 o2::framework::DataProcessorSpec getDumpPagesSpec(const char* specName)
 {
   auto inputs = o2::framework::select("TF:MCH/RAWDATA");
-  for (auto& inp : inputs) {
-    // mark input as optional in order not to block the workflow
-    // if our raw data happen to be missing in some TFs
-    inp.lifetime = Lifetime::Optional;
-  }
   //o2::mch::raw::DumpPagesTask task("TF:MCH/RAWDATA");
   return DataProcessorSpec{
     specName,
diff --git a/Detectors/MUON/MID/Workflow/src/RawDecoderSpec.cxx b/Detectors/MUON/MID/Workflow/src/RawDecoderSpec.cxx
@@ -121,14 +121,14 @@ of::DataProcessorSpec getRawDecoderSpec(bool isDebugMode)
 
 of::DataProcessorSpec getRawDecoderSpec(bool isDebugMode, const FEEIdConfig& feeIdConfig, const CrateMasks& crateMasks, const ElectronicsDelay& electronicsDelay, bool askDISTSTF)
 {
-  std::vector<of::InputSpec> inputSpecs{{"mid_raw", of::ConcreteDataTypeMatcher{header::gDataOriginMID, header::gDataDescriptionRawData}, of::Lifetime::Optional}};
+  std::vector<of::InputSpec> inputSpecs{{"mid_raw", of::ConcreteDataTypeMatcher{header::gDataOriginMID, header::gDataDescriptionRawData}, of::Lifetime::Timeframe}};
   header::DataHeader::SubSpecificationType subSpec{0};
   return getRawDecoderSpec(isDebugMode, feeIdConfig, crateMasks, electronicsDelay, inputSpecs, askDISTSTF, subSpec);
 }
 
 of::DataProcessorSpec getRawDecoderSpec(bool isDebugMode, const FEEIdConfig& feeIdConfig, const CrateMasks& crateMasks, const ElectronicsDelay& electronicsDelay, bool askDISTSTF, header::DataHeader::SubSpecificationType subSpec)
 {
-  std::vector<of::InputSpec> inputSpecs{{"mid_raw", header::gDataOriginMID, header::gDataDescriptionRawData, subSpec, o2::framework::Lifetime::Optional}};
+  std::vector<of::InputSpec> inputSpecs{{"mid_raw", header::gDataOriginMID, header::gDataDescriptionRawData, subSpec, o2::framework::Lifetime::Timeframe}};
 
   return getRawDecoderSpec(isDebugMode, feeIdConfig, crateMasks, electronicsDelay, inputSpecs, askDISTSTF, subSpec);
 }
diff --git a/Detectors/MUON/MID/Workflow/src/RawDumpSpec.cxx b/Detectors/MUON/MID/Workflow/src/RawDumpSpec.cxx
@@ -164,14 +164,14 @@ of::DataProcessorSpec getRawDumpSpec(bool isDebugMode)
 
 of::DataProcessorSpec getRawDumpSpec(bool isDebugMode, const FEEIdConfig& feeIdConfig, const CrateMasks& crateMasks, const ElectronicsDelay& electronicsDelay, bool askDISTSTF)
 {
-  std::vector<of::InputSpec> inputSpecs{{"mid_raw", of::ConcreteDataTypeMatcher{header::gDataOriginMID, header::gDataDescriptionRawData}, of::Lifetime::Optional}};
+  std::vector<of::InputSpec> inputSpecs{{"mid_raw", of::ConcreteDataTypeMatcher{header::gDataOriginMID, header::gDataDescriptionRawData}, of::Lifetime::Timeframe}};
   header::DataHeader::SubSpecificationType subSpec{0};
   return getRawDumpSpec(isDebugMode, feeIdConfig, crateMasks, electronicsDelay, inputSpecs, askDISTSTF, subSpec);
 }
 
 of::DataProcessorSpec getRawDumpSpec(bool isDebugMode, const FEEIdConfig& feeIdConfig, const CrateMasks& crateMasks, const ElectronicsDelay& electronicsDelay, bool askDISTSTF, header::DataHeader::SubSpecificationType subSpec)
 {
-  std::vector<of::InputSpec> inputSpecs{{"mid_raw", header::gDataOriginMID, header::gDataDescriptionRawData, subSpec, o2::framework::Lifetime::Optional}};
+  std::vector<of::InputSpec> inputSpecs{{"mid_raw", header::gDataOriginMID, header::gDataDescriptionRawData, subSpec, o2::framework::Lifetime::Timeframe}};
 
   return getRawDumpSpec(isDebugMode, feeIdConfig, crateMasks, electronicsDelay, inputSpecs, askDISTSTF, subSpec);
 }
diff --git a/Detectors/PHOS/workflow/src/EventBuilderSpec.cxx b/Detectors/PHOS/workflow/src/EventBuilderSpec.cxx
@@ -185,8 +185,8 @@ void EventBuilderSpec::run(framework::ProcessingContext& ctx)
 o2::framework::DataProcessorSpec o2::phos::getEventBuilderSpec()
 {
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("inputcells", "PHS", "CELLS", 1, o2::framework::Lifetime::Optional);          // Input subspec 1, output subspec 0
-  inputs.emplace_back("inputtriggers", "PHS", "CELLTRIGREC", 1, o2::framework::Lifetime::Optional); // Input subspec 1, output subspec 0
+  inputs.emplace_back("inputcells", "PHS", "CELLS", 1, o2::framework::Lifetime::Timeframe);          // Input subspec 1, output subspec 0
+  inputs.emplace_back("inputtriggers", "PHS", "CELLTRIGREC", 1, o2::framework::Lifetime::Timeframe); // Input subspec 1, output subspec 0
   // output should be anyway generated by raw converter. Or not?
   //  inputs.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
 
diff --git a/Detectors/PHOS/workflow/src/RawToCellConverterSpec.cxx b/Detectors/PHOS/workflow/src/RawToCellConverterSpec.cxx
@@ -301,7 +301,7 @@ void RawToCellConverterSpec::run(framework::ProcessingContext& ctx)
 o2::framework::DataProcessorSpec o2::phos::reco_workflow::getRawToCellConverterSpec(unsigned int flpId)
 {
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("RAWDATA", o2::framework::ConcreteDataTypeMatcher{"PHS", "RAWDATA"}, o2::framework::Lifetime::Optional);
+  inputs.emplace_back("RAWDATA", o2::framework::ConcreteDataTypeMatcher{"PHS", "RAWDATA"}, o2::framework::Lifetime::Timeframe);
   // receive at least 1 guaranteed input (which will allow to acknowledge the TF)
   inputs.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);
   inputs.emplace_back("recoparams", o2::header::gDataOriginPHS, "PHS_RecoParams", 0, o2::framework::Lifetime::Condition, o2::framework::ccdbParamSpec("PHS/Config/RecoParams"));
diff --git a/Detectors/Raw/src/RawDumpSpec.cxx b/Detectors/Raw/src/RawDumpSpec.cxx
@@ -674,7 +674,7 @@ DataProcessorSpec getRawDumpSpec(DetID::mask_t detMask, bool TOFUncompressed)
   o2h::DataOrigin orig;
   for (DetID::ID id = DetID::First; id <= DetID::Last; id++) {
     if (detMask[id] && (orig = DetID::getDataOrigin(id)) != o2h::gDataOriginInvalid) {
-      inputs.emplace_back(DetID::getName(id), ConcreteDataTypeMatcher{orig, (id != DetID::TOF || TOFUncompressed) ? RawDump::DESCRaw : RawDump::DESCCRaw}, Lifetime::Optional);
+      inputs.emplace_back(DetID::getName(id), ConcreteDataTypeMatcher{orig, (id != DetID::TOF || TOFUncompressed) ? RawDump::DESCRaw : RawDump::DESCCRaw}, Lifetime::Timeframe);
     }
   }
   return DataProcessorSpec{
diff --git a/Detectors/TOF/compression/src/tof-compressor.cxx b/Detectors/TOF/compression/src/tof-compressor.cxx
@@ -109,9 +109,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   while (getline(ssconfig, iconfig, ',')) {
     std::vector<InputSpec> inputs = select(iconfig.c_str());
     if (!ignoreStf) {
-      for (auto& val : inputs) {
-        val.lifetime = Lifetime::Optional;
-      }
       inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
     }
     workflow.emplace_back(DataProcessorSpec{
diff --git a/Detectors/TOF/workflow/src/CompressedDecodingTask.cxx b/Detectors/TOF/workflow/src/CompressedDecodingTask.cxx
@@ -459,11 +459,7 @@ DataProcessorSpec getCompressedDecodingSpec(const std::string& inputDesc, bool c
   //  inputs.emplace_back(std::string("x:TOF/" + inputDesc).c_str(), 0, Lifetime::Optional);
   o2::header::DataDescription dataDesc;
   dataDesc.runtimeInit(inputDesc.c_str());
-  if (localCmp) {
-    inputs.emplace_back("x", ConcreteDataTypeMatcher{o2::header::gDataOriginTOF, dataDesc}, Lifetime::Timeframe);
-  } else {
-    inputs.emplace_back("x", ConcreteDataTypeMatcher{o2::header::gDataOriginTOF, dataDesc}, Lifetime::Optional);
-  }
+  inputs.emplace_back("x", ConcreteDataTypeMatcher{o2::header::gDataOriginTOF, dataDesc}, Lifetime::Timeframe);
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(o2::header::gDataOriginTOF, "DIGITHEADER", 0, Lifetime::Timeframe);
   outputs.emplace_back(o2::header::gDataOriginTOF, "DIGITS", 0, Lifetime::Timeframe);
diff --git a/Detectors/TPC/workflow/src/RawToDigitsSpec.cxx b/Detectors/TPC/workflow/src/RawToDigitsSpec.cxx
@@ -261,7 +261,7 @@ DataProcessorSpec getRawToDigitsSpec(int channel, const std::string inputSpec, b
   if (inputSpec != "") {
     inputs = select(inputSpec.data());
   } else {
-    inputs.emplace_back(InputSpec{"zsraw", ConcreteDataTypeMatcher{"TPC", "RAWDATA"}, Lifetime::Optional});
+    inputs.emplace_back(InputSpec{"zsraw", ConcreteDataTypeMatcher{"TPC", "RAWDATA"}, Lifetime::Timeframe});
     if (!ignoreDistStf) {
       inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
     }
diff --git a/Detectors/TPC/workflow/src/SACProcessorSpec.cxx b/Detectors/TPC/workflow/src/SACProcessorSpec.cxx
@@ -159,7 +159,7 @@ o2::framework::DataProcessorSpec getSACProcessorSpec()
   using device = o2::tpc::SACProcessorDevice;
 
   std::vector<InputSpec> inputs;
-  inputs.emplace_back(InputSpec{"tpcraw", ConcreteDataTypeMatcher{"TPC", "RAWDATA"}, Lifetime::Optional});
+  inputs.emplace_back(InputSpec{"tpcraw", ConcreteDataTypeMatcher{"TPC", "RAWDATA"}, Lifetime::Timeframe});
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
                                                                 true,                           // GRPECS=true
                                                                 false,                          // GRPLHCIF
diff --git a/Detectors/TRD/reconstruction/src/DataReader.cxx b/Detectors/TRD/reconstruction/src/DataReader.cxx
@@ -89,10 +89,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec workflow;
 
   auto inputs = o2::framework::select(std::string("x:TRD/RAWDATA").c_str());
-  for (auto& inp : inputs) {
-    // take care of case where our data is not in the time frame
-    inp.lifetime = Lifetime::Optional;
-  }
   if (askSTFDist) {
     inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
   }
diff --git a/Detectors/ZDC/raw/src/ZDCRawParserDPLSpec.cxx b/Detectors/ZDC/raw/src/ZDCRawParserDPLSpec.cxx
@@ -158,7 +158,7 @@ framework::DataProcessorSpec getZDCRawParserDPLSpec()
 {
   using device = o2::zdc::ZDCRawParserDPLSpec;
   std::vector<InputSpec> inputs;
-  inputs.emplace_back("raw", o2::framework::ConcreteDataTypeMatcher{"ZDC", "RAWDATA"}, Lifetime::Optional);
+  inputs.emplace_back("raw", o2::framework::ConcreteDataTypeMatcher{"ZDC", "RAWDATA"}, Lifetime::Timeframe);
 
   std::vector<OutputSpec> outputs;
   return DataProcessorSpec{
diff --git a/Detectors/ZDC/workflow/src/ZDCDataReaderDPLSpec.cxx b/Detectors/ZDC/workflow/src/ZDCDataReaderDPLSpec.cxx
@@ -140,7 +140,7 @@ framework::DataProcessorSpec getZDCDataReaderDPLSpec(const RawReaderZDC& rawRead
   LOG(info) << "DataProcessorSpec initDataProcSpec() for RawReaderZDC";
   std::vector<OutputSpec> outputSpec;
   RawReaderZDC::prepareOutputSpec(outputSpec);
-  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginZDC, "RAWDATA"}, Lifetime::Optional}};
+  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginZDC, "RAWDATA"}, Lifetime::Timeframe}};
   inputSpec.emplace_back("moduleconfig", "ZDC", "MODULECONFIG", 0, Lifetime::Condition, o2::framework::ccdbParamSpec(o2::zdc::CCDBPathConfigModule.data()));
   if (askSTFDist) {
     inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);

Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ void RawToDigitConverterSpec::run(framework::ProcessingContext& ctx)`
`313`	`313`	`o2::framework::DataProcessorSpec o2::cpv::reco_workflow::getRawToDigitConverterSpec(bool askDISTSTF, bool isPedestal, bool useBadChannelMap, bool useGainCalibration)`
`314`	`314`	`{`
`315`	`315`	`std::vector<o2::framework::InputSpec> inputs;`
`316`		`- inputs.emplace_back("RAWDATA", o2::framework::ConcreteDataTypeMatcher{"CPV", "RAWDATA"}, o2::framework::Lifetime::Optional);`
	`316`	`+ inputs.emplace_back("RAWDATA", o2::framework::ConcreteDataTypeMatcher{"CPV", "RAWDATA"}, o2::framework::Lifetime::Timeframe);`
`317`	`317`	`// receive at least 1 guaranteed input (which will allow to acknowledge the TF)`
`318`	`318`	`if (askDISTSTF) {`
`319`	`319`	`inputs.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ o2::framework::DataProcessorSpec o2::ctp::reco_workflow::getRawDecoderSpec(bool`
`166`	`166`	`throw std::runtime_error("all outputs were disabled");`
`167`	`167`	`}`
`168`	`168`	`std::vector<o2::framework::InputSpec> inputs;`
`169`		`- inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"CTP", "RAWDATA"}, o2::framework::Lifetime::Optional);`
	`169`	`+ inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"CTP", "RAWDATA"}, o2::framework::Lifetime::Timeframe);`
`170`	`170`	`if (askDISTSTF) {`
`171`	`171`	`inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);`
`172`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -750,7 +750,7 @@ o2::framework::DataProcessorSpec o2::emcal::reco_workflow::getRawToCellConverter`
`750`	`750`	`outputs.emplace_back(originEMC, "DECODERERR", subspecification, o2::framework::Lifetime::Timeframe);`
`751`	`751`	`}`
`752`	`752`
`753`		`- std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originEMC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Optional}};`
	`753`	`+ std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originEMC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Timeframe}};`
`754`	`754`	`if (askDISTSTF) {`
`755`	`755`	`inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);`
`756`	`756`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ framework::DataProcessorSpec getFT0DataDecoderDPLSpec(bool askSTFDist)`
`110`	`110`	`std::vector<OutputSpec> outputSpec;`
`111`	`111`	`outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSBC", 0, Lifetime::Timeframe);`
`112`	`112`	`outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSCH", 0, Lifetime::Timeframe);`
`113`		`- std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{"FT0", "RAWDATA"}, Lifetime::Optional}};`
	`113`	`+ std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{"FT0", "RAWDATA"}, Lifetime::Timeframe}};`
`114`	`114`	`if (askSTFDist) {`
`115`	`115`	`inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ framework::DataProcessorSpec getFT0DataReaderDPLSpec(const RawReader& rawReader,`
`92`	`92`	`LOG(info) << "DataProcessorSpec initDataProcSpec() for RawReaderFT0";`
`93`	`93`	`std::vector<OutputSpec> outputSpec;`
`94`	`94`	`RawReader::prepareOutputSpec(outputSpec);`
`95`		`- std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginFT0, "RAWDATA"}, Lifetime::Optional}};`
	`95`	`+ std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginFT0, "RAWDATA"}, Lifetime::Timeframe}};`
`96`	`96`	`if (askSTFDist) {`
`97`	`97`	`inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,7 @@ framework::DataProcessorSpec getFITDataReaderDPLSpec(const RawReaderType& rawRea`
`175`	`175`	`inputSpec.push_back({"STF", ConcreteDataTypeMatcher{rawReader.mDataOrigin, "SUB_RAWDATA"}, Lifetime::Sporadic}); // in case if one need to use DataSampler`
`176`	`176`	`askSTFDist = false;`
`177`	`177`	`} else {`
`178`		`- inputSpec.push_back({"STF", ConcreteDataTypeMatcher{rawReader.mDataOrigin, "RAWDATA"}, Lifetime::Optional});`
	`178`	`+ inputSpec.push_back({"STF", ConcreteDataTypeMatcher{rawReader.mDataOrigin, "RAWDATA"}, Lifetime::Timeframe});`
`179`	`179`	`}`
`180`	`180`	`if (askSTFDist) {`
`181`	`181`	`inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);`
Original file line number	Diff line number	Diff line change
`@@ -675,7 +675,7 @@ o2::framework::DataProcessorSpec o2::focal::reco_workflow::getRawDecoderSpec(boo`
`675`	`675`	`outputs.emplace_back(originFOC, "PIXELCHIPS", outputSubspec, o2::framework::Lifetime::Timeframe);`
`676`	`676`	`outputs.emplace_back(originFOC, "TRIGGERS", outputSubspec, o2::framework::Lifetime::Timeframe);`
`677`	`677`
`678`		`- std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originFOC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Optional}};`
	`678`	`+ std::vector<o2::framework::InputSpec> inputs{{"stf", o2::framework::ConcreteDataTypeMatcher{originFOC, o2::header::gDataDescriptionRawData}, o2::framework::Lifetime::Timeframe}};`
`679`	`679`	`if (askDISTSTF) {`
`680`	`680`	`inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);`
`681`	`681`	`}`
Original file line number	Diff line number	Diff line change
`@@ -280,7 +280,7 @@ void DataDecoderTask::decodeRawFile(framework::ProcessingContext& pc)`
`280`	`280`	`o2::framework::DataProcessorSpec getDecodingSpec(bool askDISTSTF)`
`281`	`281`	`{`
`282`	`282`	`std::vector<o2::framework::InputSpec> inputs;`
`283`		`- inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Optional);`
	`283`	`+ inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Timeframe);`
`284`	`284`	`if (askDISTSTF) {`
`285`	`285`	`inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);`
`286`	`286`	`}`
Original file line number	Diff line number	Diff line change
`@@ -336,7 +336,7 @@ void DataDecoderTask2::orderTriggers()`
`336`	`336`	`o2::framework::DataProcessorSpec getDecodingSpec2(bool askDISTSTF)`
`337`	`337`	`{`
`338`	`338`	`std::vector<o2::framework::InputSpec> inputs;`
`339`		`- inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Optional);`
	`339`	`+ inputs.emplace_back("TF", o2::framework::ConcreteDataTypeMatcher{"HMP", "RAWDATA"}, o2::framework::Lifetime::Timeframe);`
`340`	`340`	`if (askDISTSTF) {`
`341`	`341`	`inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);`
`342`	`342`	`}`
Original file line number	Diff line number	Diff line change
`@@ -356,9 +356,6 @@ DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)`
`356`	`356`	`outputs.emplace_back(inp.origin, "ChipErrors", 0, Lifetime::Timeframe);`
`357`	`357`
`358`	`358`	`if (inp.askSTFDist) {`
`359`		`- for (auto& ins : inputs) { // mark input as optional in order not to block the workflow if our raw data happen to be missing in some TFs`
`360`		`- ins.lifetime = Lifetime::Optional;`
`361`		`- }`
`362`	`359`	`// request the input FLP/DISTSUBTIMEFRAME/0 that is _guaranteed_ to be present, even if none of our raw data is present.`
`363`	`360`	`inputs.emplace_back("stfDist", "FLP", "DISTSUBTIMEFRAME", 0, o2::framework::Lifetime::Timeframe);`
`364`	`361`	`}`