diff --git a/EventFilter/Utilities/interface/DAQSourceModels.h b/EventFilter/Utilities/interface/DAQSourceModels.h
index 0015b4a7a62..7b0b7470179 100644
--- a/EventFilter/Utilities/interface/DAQSourceModels.h
+++ b/EventFilter/Utilities/interface/DAQSourceModels.h
@@ -72,7 +72,9 @@ public:
 
   //pre-parse file to count events
   virtual bool hasEventCounterCallback() const { return false; }
-  virtual int eventCounterCallback(std::string const& name, int& fd, int64_t& fsize, uint32_t sLS, bool& found) const { return -1;}
+  virtual int eventCounterCallback(std::string const& name, int& fd, int64_t& fsize, uint32_t sLS, bool& found) const {
+    return -1;
+  }
 
 protected:
   DAQSource* daqSource_;
diff --git a/EventFilter/Utilities/interface/DAQSourceModelsScoutingRun3.h b/EventFilter/Utilities/interface/DAQSourceModelsScoutingRun3.h
index 2c110f9f348..e3f6dead5b3 100644
--- a/EventFilter/Utilities/interface/DAQSourceModelsScoutingRun3.h
+++ b/EventFilter/Utilities/interface/DAQSourceModelsScoutingRun3.h
@@ -104,7 +104,6 @@ public:
   std::pair<bool, std::vector<std::string>> defineAdditionalFiles(std::string const& primaryName,
                                                                   bool fileListMode) const override;
 
-
 private:
   bool makeEvents();
   std::vector<std::shared_ptr<const edm::DaqProvenanceHelper>> daqProvenanceHelpers_;  //
diff --git a/EventFilter/Utilities/interface/DTHHeaders.h b/EventFilter/Utilities/interface/DTHHeaders.h
index 411c9c51c9d..4b1660322ed 100644
--- a/EventFilter/Utilities/interface/DTHHeaders.h
+++ b/EventFilter/Utilities/interface/DTHHeaders.h
@@ -15,15 +15,13 @@
 
 namespace evf {
   constexpr uint32_t SLR_MAX_EVENT_LEN = (1 << 20) - 1;
-  constexpr std::array<uint8_t, 2> DTHOrbitMarker{{0x48, 0x4f}}; //HO
-  constexpr std::array<uint8_t, 2> DTHFragmentTrailerMarker{{0x54, 0x46}}; //TF
+  constexpr std::array<uint8_t, 2> DTHOrbitMarker{{0x48, 0x4f}};            //HO
+  constexpr std::array<uint8_t, 2> DTHFragmentTrailerMarker{{0x54, 0x46}};  //TF
   constexpr uint32_t DTH_WORD_NUM_BYTES_SHIFT = 4;
   constexpr uint32_t SLR_WORD_NUM_BYTES_SHIFT = 4;
 
-
   class DTHOrbitHeader_v1 {
   public:
-
     DTHOrbitHeader_v1(uint32_t source_id,
                       uint32_t run_number,
                       uint32_t orbit_number,
@@ -37,10 +35,9 @@ namespace evf {
           event_count_(event_count),
           packed_word_count_(packed_word_count),
           crc32c_(crc) {
-            flags_.all_ = flags;
+      flags_.all_ = flags;
     }
 
-
     uint16_t version() const { return version_; }
     uint32_t sourceID() const { return source_id_; }
     uint32_t runNumber() const { return run_number_; }
@@ -66,39 +63,28 @@ namespace evf {
 
   private:
     std::array<uint8_t, 2> marker_ = DTHOrbitMarker;
-    uint16_t version_ = 1; //bytes: 01 00
+    uint16_t version_ = 1;  //bytes: 01 00
     uint32_t source_id_;
     uint32_t run_number_;
     uint32_t orbit_number_;
-    uint32_t event_count_:12,
-	     res_:20;
-    uint32_t packed_word_count_; //Total size encoded in multiples of 128 bits (16 bytes)
+    uint32_t event_count_ : 12, res_ : 20;
+    uint32_t packed_word_count_;  //Total size encoded in multiples of 128 bits (16 bytes)
     union {
-	struct {
-	uint32_t error_flag_:1,
-		res_flags_:31;
-	} bits_;
-	uint32_t all_;
+      struct {
+        uint32_t error_flag_ : 1, res_flags_ : 31;
+      } bits_;
+      uint32_t all_;
     } flags_;
     uint32_t crc32c_;
   };
 
-
   class DTHFragmentTrailer_v1 {
   public:
-
-    DTHFragmentTrailer_v1(
-                          uint16_t flags,
-                          uint32_t payload_word_count,
-                          uint64_t event_id,
-                          uint16_t crc)
-        : payload_word_count_(payload_word_count),
-          event_id_(event_id),
-          crc_(crc) {
+    DTHFragmentTrailer_v1(uint16_t flags, uint32_t payload_word_count, uint64_t event_id, uint16_t crc)
+        : payload_word_count_(payload_word_count), event_id_(event_id), crc_(crc) {
       flags_.all_ = flags;
     }
 
-
     uint64_t eventID() const { return event_id_; }
     uint32_t payloadWordCount() const { return payload_word_count_; }
     uint64_t payloadSizeBytes() const { return uint64_t(payload_word_count_) << DTH_WORD_NUM_BYTES_SHIFT; }
@@ -117,24 +103,16 @@ namespace evf {
     std::array<uint8_t, 2> marker_ = DTHFragmentTrailerMarker;
     union {
       struct {
-        uint16_t fed_crc_error_:1,
-	         slink_crc_error_:1,
-	         source_id_error_:1,
-		 fragment_cut_:1,
-		 event_id_sync_error_:1,
-		 fragment_timout_:1,
-		 fragment_length_error_:1,
-		 res_:9;
+        uint16_t fed_crc_error_ : 1, slink_crc_error_ : 1, source_id_error_ : 1, fragment_cut_ : 1,
+            event_id_sync_error_ : 1, fragment_timout_ : 1, fragment_length_error_ : 1, res_ : 9;
       } bits_;
       uint16_t all_;
     } flags_;
-    uint32_t payload_word_count_;  // Fragment size is encoded in multiples of 128 bits (16 bytes). I.e needs to be shifted by 4
-    uint64_t event_id_:44,
-             res_:4,
-             crc_:16;
+    uint32_t
+        payload_word_count_;  // Fragment size is encoded in multiples of 128 bits (16 bytes). I.e needs to be shifted by 4
+    uint64_t event_id_ : 44, res_ : 4, crc_ : 16;
   };
 
-
   //SLinkExpress classes
 
   //begin and end event markers
@@ -149,66 +127,42 @@ namespace evf {
     bool verifyMarker() const { return boe_ == SLR_BOE; }
 
   private:
-    uint8_t res_:4,
-	    version_:4;
+    uint8_t res_ : 4, version_ : 4;
     uint8_t boe_ = SLR_BOE;
-
   };
 
   class SLinkRocketHeader_v3 {
   public:
-
-    SLinkRocketHeader_v3(uint32_t source_id,
-                         uint16_t l1a_types,
-                         uint8_t l1a_phys,
-                         uint8_t emu_status,
-                         uint64_t event_id)
+    SLinkRocketHeader_v3(uint32_t source_id, uint16_t l1a_types, uint8_t l1a_phys, uint8_t emu_status, uint64_t event_id)
         : source_id_(source_id),
           l1a_types_(l1a_types),
           phys_type_(l1a_phys),
           emu_status_(emu_status),
           event_id_(event_id) {}
 
-
     uint32_t sourceID() const { return source_id_; }
     uint16_t l1aTypes() const { return l1a_types_; }
     uint8_t l1aPhysType() const { return phys_type_; }
     uint8_t emuStatus() const { return emu_status_; }
-    uint64_t globalEventID() const { return event_id_;}
+    uint64_t globalEventID() const { return event_id_; }
     uint8_t version() const { return version_; }
     bool verifyMarker() const { return boe_ == SLR_BOE; }
 
   private:
     uint32_t source_id_;
     uint16_t l1a_types_;
-    uint8_t  phys_type_;
-    uint8_t  emu_status_:2,
-	     res1_:6;
-    uint64_t event_id_:44,
-	     res2_:8,
-	     version_:4 = 3,
-	     boe_:8 = SLR_BOE;
+    uint8_t phys_type_;
+    uint8_t emu_status_ : 2, res1_ : 6;
+    uint64_t event_id_ : 44, res2_ : 8, version_ : 4 = 3, boe_ : 8 = SLR_BOE;
   };
 
-
   class SLinkRocketTrailer_v3 {
   public:
-
     SLinkRocketTrailer_v3(
-        uint16_t status,
-        uint16_t crc,
-        uint32_t orbit_id,
-        uint16_t bx_id,
-        uint32_t evtlen_word_count,
-        uint16_t daq_crc)
-        : crc_(crc),
-          orbit_id_(orbit_id),
-          bx_id_(bx_id),
-          event_length_wcount_(evtlen_word_count),
-          daq_crc_(daq_crc) {
-     status_.all_ = status;
-   }
-
+        uint16_t status, uint16_t crc, uint32_t orbit_id, uint16_t bx_id, uint32_t evtlen_word_count, uint16_t daq_crc)
+        : crc_(crc), orbit_id_(orbit_id), bx_id_(bx_id), event_length_wcount_(evtlen_word_count), daq_crc_(daq_crc) {
+      status_.all_ = status;
+    }
 
     uint16_t status() const { return status_.all_; }
     uint16_t crc() const { return crc_; }
@@ -219,26 +173,23 @@ namespace evf {
     bool verifyMarker() const { return eoe_ == SLR_EOE; }
 
   private:
-
     union {
       struct {
-        uint16_t fed_crc_error_:1,     /* FED CRC error was detected by DTH and corrected */
-                 slink_crc_error_:1,   /* Set when the slink receviver finds a mistmatch between calculated crc and daq_crc. It should never happen */
-                 source_id_error_:1,   /* SOURCE_ID is not expected */
-                 sync_lost_error_:1,   /* Sync lost detected by DTH */
-                 fragment_cut_:1,      /* Fragment was cut */
-                 res_:11;
+        uint16_t fed_crc_error_ : 1, /* FED CRC error was detected by DTH and corrected */
+            slink_crc_error_ : 1, /* Set when the slink receviver finds a mistmatch between calculated crc and daq_crc. It should never happen */
+            source_id_error_ : 1, /* SOURCE_ID is not expected */
+            sync_lost_error_ : 1, /* Sync lost detected by DTH */
+            fragment_cut_ : 1,    /* Fragment was cut */
+            res_ : 11;
       } bits_;
       uint16_t all_;
     } status_;
-    uint16_t crc_;                         /* CRC filled by the FED */
+    uint16_t crc_; /* CRC filled by the FED */
     uint32_t orbit_id_;
-    uint32_t bx_id_:12,
-             event_length_wcount_:20;      /* Length is encoded in multiples of 128 bits (16 bytes). I.e needs to be shifter by 4 */
-    uint32_t reserved_:8,
-             daq_crc_:16,                  /* CRC filled by the slink sender */
-             eoe_:8 = SLR_EOE;
-
+    uint32_t bx_id_ : 12,
+        event_length_wcount_ : 20; /* Length is encoded in multiples of 128 bits (16 bytes). I.e needs to be shifter by 4 */
+    uint32_t reserved_ : 8, daq_crc_ : 16, /* CRC filled by the slink sender */
+        eoe_ : 8 = SLR_EOE;
   };
 
 }  // namespace evf
diff --git a/EventFilter/Utilities/interface/EvFDaqDirector.h b/EventFilter/Utilities/interface/EvFDaqDirector.h
index c9564f60a3f..5ffe3ee2cd3 100644
--- a/EventFilter/Utilities/interface/EvFDaqDirector.h
+++ b/EventFilter/Utilities/interface/EvFDaqDirector.h
@@ -189,7 +189,6 @@ namespace evf {
     unsigned int lsWithFilesOpen(unsigned int ls) const;
 
   private:
-
     void createLumiSectionFiles(const uint32_t lumiSection,
                                 const uint32_t currentLumiSection,
                                 bool doCreateBoLS,
@@ -224,7 +223,7 @@ namespace evf {
                   bool& setExceptionState);
     void openFULockfileStream(bool create);
     static bool checkFileRead(char* buf, int& infile, std::size_t buf_sz, std::string const& path);
-    bool hasFRDFileHeader(std::string const& rawPath, int& rawFd, bool &hasErr, bool closeFile) const;
+    bool hasFRDFileHeader(std::string const& rawPath, int& rawFd, bool& hasErr, bool closeFile) const;
     std::string inputFileNameStem(const unsigned int ls, const unsigned int index) const;
     std::string outputFileNameStem(const unsigned int ls, std::string const& stream) const;
     std::string mergedFileNameStem(const unsigned int ls, std::string const& stream) const;
diff --git a/EventFilter/Utilities/interface/SourceRawFile.h b/EventFilter/Utilities/interface/SourceRawFile.h
index ce53bcb8416..5ec3840d603 100644
--- a/EventFilter/Utilities/interface/SourceRawFile.h
+++ b/EventFilter/Utilities/interface/SourceRawFile.h
@@ -193,20 +193,18 @@ public:
   int64_t fileSizeLeft() const { return (int64_t)fileSize_ - (int64_t)bufferPosition_; }
   int64_t fileSizeLeft(size_t fidx) const { return (int64_t)diskFileSizes_[fidx] - (int64_t)bufferOffsets_[fidx]; }
 
-  bool complete() const {
-    return bufferPosition_ == fileSize_;
-  }
+  bool complete() const { return bufferPosition_ == fileSize_; }
 
   bool buffersComplete() const {
     unsigned complete = 0;
-    for (size_t fidx=0; fidx < bufferOffsets_.size() ; fidx++) {
-      if ((int64_t)bufferEnds_[fidx] - (int64_t)bufferOffsets_[fidx] == 0) complete++;
+    for (size_t fidx = 0; fidx < bufferOffsets_.size(); fidx++) {
+      if ((int64_t)bufferEnds_[fidx] - (int64_t)bufferOffsets_[fidx] == 0)
+        complete++;
     }
     if (complete && complete < bufferOffsets_.size())
-        throw cms::Exception("InputFile") << "buffers are inconsistent for input files with primary " << fileName_;
+      throw cms::Exception("InputFile") << "buffers are inconsistent for input files with primary " << fileName_;
     return complete > 0;
   }
-
 };
 
 class DAQSource;
@@ -231,12 +229,10 @@ public:
     bufferPosition_ += size;
   }
   void advanceBuffers(const size_t size) {
-    for (size_t bidx=0; bidx < bufferOffsets_.size(); bidx++)
+    for (size_t bidx = 0; bidx < bufferOffsets_.size(); bidx++)
       bufferOffsets_[bidx] += size;
   }
-  void advanceBuffer(const size_t size, const size_t bidx) {
-    bufferOffsets_[bidx] += size;
-  }
+  void advanceBuffer(const size_t size, const size_t bidx) { bufferOffsets_[bidx] += size; }
   void queue(UnpackedRawEventWrapper* ec) {
     if (!frdcQueue_.get())
       frdcQueue_ = std::make_unique<std::queue<std::unique_ptr<UnpackedRawEventWrapper>>>();
diff --git a/EventFilter/Utilities/src/DAQSource.cc b/EventFilter/Utilities/src/DAQSource.cc
index e74b1afd952..700e035640b 100644
--- a/EventFilter/Utilities/src/DAQSource.cc
+++ b/EventFilter/Utilities/src/DAQSource.cc
@@ -113,12 +113,11 @@ DAQSource::DAQSource(edm::ParameterSet const& pset, edm::InputSourceDescription
     }
   }
 
-  dataMode_->makeDirectoryEntries(
-      daqDirector_->getBUBaseDirs(),
-      daqDirector_->getBUBaseDirsNSources(),
-      daqDirector_->getBUBaseDirsSourceIDs(),
-      daqDirector_->getSourceIdentifier(),
-      daqDirector_->runString());
+  dataMode_->makeDirectoryEntries(daqDirector_->getBUBaseDirs(),
+                                  daqDirector_->getBUBaseDirsNSources(),
+                                  daqDirector_->getBUBaseDirsSourceIDs(),
+                                  daqDirector_->getSourceIdentifier(),
+                                  daqDirector_->runString());
 
   auto& daqProvenanceHelpers = dataMode_->makeDaqProvenanceHelpers();
   for (const auto& daqProvenanceHelper : daqProvenanceHelpers)
@@ -514,7 +513,8 @@ evf::EvFDaqDirector::FileStatus DAQSource::getNextDataBlock() {
     currentFile_->advance(currentFile_->rawHeaderSize_);
     currentFile_->advanceBuffers(currentFile_->rawHeaderSize_);
   }
-  LogDebug("DAQSource") << "after header bufferPosition: " << currentFile_->bufferPosition_ << " fileSizeLeft:" << currentFile_->fileSizeLeft();
+  LogDebug("DAQSource") << "after header bufferPosition: " << currentFile_->bufferPosition_
+                        << " fileSizeLeft:" << currentFile_->fileSizeLeft();
 
   //file is too short to fit event (or event block, orbit...) header
   if (currentFile_->fileSizeLeft() < dataMode_->headerSize())
@@ -830,8 +830,8 @@ void DAQSource::readSupervisor() {
           }
         }
       } else {
-
-        RawFileEvtCounter countFunc = [&](std::string const& name, int& fd, int64_t& fsize, uint32_t sLS, bool& found) -> unsigned int {
+        RawFileEvtCounter countFunc =
+            [&](std::string const& name, int& fd, int64_t& fsize, uint32_t sLS, bool& found) -> unsigned int {
           return dataMode_->eventCounterCallback(name, fd, fsize, sLS, found);
         };
 
diff --git a/EventFilter/Utilities/src/DAQSourceModelsDTH.cc b/EventFilter/Utilities/src/DAQSourceModelsDTH.cc
index 2ebe9402045..f70588ac0f3 100644
--- a/EventFilter/Utilities/src/DAQSourceModelsDTH.cc
+++ b/EventFilter/Utilities/src/DAQSourceModelsDTH.cc
@@ -30,7 +30,6 @@
 #include "DataFormats/Provenance/interface/Timestamp.h"
 #include "EventFilter/Utilities/interface/crc32c.h"
 
-
 using namespace evf;
 
 void DataModeDTH::readEvent(edm::EventPrincipal& eventPrincipal) {
@@ -117,7 +116,6 @@ std::vector<std::shared_ptr<const edm::DaqProvenanceHelper>>& DataModeDTH::makeD
 }
 
 void DataModeDTH::makeDataBlockView(unsigned char* addr, RawInputFile* rawFile) {
-
   //addr points to beginning of the main file orbit block
 
   //get file array info
@@ -138,13 +136,12 @@ void DataModeDTH::makeDataBlockView(unsigned char* addr, RawInputFile* rawFile)
     bool ohThisFile = false;
     //intial orbit header was advanced over by source (first file only)
     auto nextAddr = buf + rawFile->bufferOffsets_[i];
-    auto startAddr = nextAddr;//save start position of the orbit
-    auto maxAddr = buf + rawFile->bufferEnds_[i];//end of stripe / file
+    auto startAddr = nextAddr;                     //save start position of the orbit
+    auto maxAddr = buf + rawFile->bufferEnds_[i];  //end of stripe / file
 
-
-    LogDebug("DataModeDTH") << "make data block view for file " << i << " at offsets: " << rawFile->bufferOffsets_[i] << " to: " << rawFile->bufferEnds_[i]
-                            << " blockAddr: 0x" << std::hex << (uint64_t)nextAddr << " chunkOffset: 0x"
-                            << std::hex << (uint64_t)(nextAddr - buf);
+    LogDebug("DataModeDTH") << "make data block view for file " << i << " at offsets: " << rawFile->bufferOffsets_[i]
+                            << " to: " << rawFile->bufferEnds_[i] << " blockAddr: 0x" << std::hex << (uint64_t)nextAddr
+                            << " chunkOffset: 0x" << std::hex << (uint64_t)(nextAddr - buf);
 
     checksumValid_ = true;
     if (!checksumError_.empty())
@@ -179,9 +176,8 @@ void DataModeDTH::makeDataBlockView(unsigned char* addr, RawInputFile* rawFile)
           //each file must contain at least one orbit nr of the first file
           assert(orbitHeader->orbitNumber() == firstOrbitHeader_->orbitNumber());
           ohThisFile = true;
-        } else
-          if (orbitHeader->orbitNumber() != firstOrbitHeader_->orbitNumber())
-            break;
+        } else if (orbitHeader->orbitNumber() != firstOrbitHeader_->orbitNumber())
+          break;
         assert(orbitHeader->eventCount() == firstOrbitHeader_->eventCount());
       }
 
@@ -191,25 +187,24 @@ void DataModeDTH::makeDataBlockView(unsigned char* addr, RawInputFile* rawFile)
           checksumValid_ = false;
           if (!checksumError_.empty())
             checksumError_ += "\n";
-          checksumError_ +=
-            fmt::format("Found a wrong crc32c checksum in orbit header v{} run: {} orbit: {} sourceId: {} wcount: {} events: {} flags: {}. Expected {:x} but calculated {:x}",
-                        orbitHeader->version(),
-                        orbitHeader->runNumber(),
-                        orbitHeader->orbitNumber(),
-                        orbitHeader->sourceID(),
-                        orbitHeader->packed_word_count(),
-                        orbitHeader->eventCount(),
-                        orbitHeader->flags(),
-                        orbitHeader->crc(),
-                        crc);
+          checksumError_ += fmt::format(
+              "Found a wrong crc32c checksum in orbit header v{} run: {} orbit: {} sourceId: {} wcount: {} events: {} "
+              "flags: {}. Expected {:x} but calculated {:x}",
+              orbitHeader->version(),
+              orbitHeader->runNumber(),
+              orbitHeader->orbitNumber(),
+              orbitHeader->sourceID(),
+              orbitHeader->packed_word_count(),
+              orbitHeader->eventCount(),
+              orbitHeader->flags(),
+              orbitHeader->crc(),
+              crc);
         }
       }
-      LogDebug("DataModeDTH") << "DTH orbit block version:"  << orbitHeader->version()
-                              << " sourceID:" << orbitHeader->sourceID()
-                              << " run:" << orbitHeader->runNumber()
+      LogDebug("DataModeDTH") << "DTH orbit block version:" << orbitHeader->version()
+                              << " sourceID:" << orbitHeader->sourceID() << " run:" << orbitHeader->runNumber()
                               << " orbitNr:" << orbitHeader->orbitNumber()
-                              << " evtFragments:" << orbitHeader->eventCount()
-                              << " crc32c:" << orbitHeader->crc()
+                              << " evtFragments:" << orbitHeader->eventCount() << " crc32c:" << orbitHeader->crc()
                               << " flagMask:" << std::hex << orbitHeader->flags();
       //push current orbit to the list of orbits
       auto srcOrbitSize = orbitHeader->totalSize();
@@ -256,14 +251,14 @@ bool DataModeDTH::nextEventView(RawInputFile*) {
   size_t last_eID = 0;
 
   for (size_t i = 0; i < addrsEnd_.size(); i++) {
-
     if (addrsEnd_[i] == addrsStart_[i]) {
       blockCompletedAny = true;
       continue;
     } else {
       assert(addrsEnd_[i] > addrsStart_[i]);
       blockCompletedAll = false;
-      if (blockCompletedAny) continue;
+      if (blockCompletedAny)
+        continue;
     }
 
     evf::DTHFragmentTrailer_v1* trailer =
@@ -293,8 +288,7 @@ bool DataModeDTH::nextEventView(RawInputFile*) {
           << " flags: " << std::bitset<16>(trailer->flags());
 
     LogDebug("DataModeDTH") << "DTH fragment trailer in block " << i << " eventID: " << trailer->eventID()
-                            << " payloadSizeBytes: " <<  trailer->payloadSizeBytes()
-                            << " crc: " << trailer->crc()
+                            << " payloadSizeBytes: " << trailer->payloadSizeBytes() << " crc: " << trailer->crc()
                             << " flagMask: " << std::hex << trailer->flags();
 
     //update address array
@@ -322,10 +316,10 @@ bool DataModeDTH::nextEventView(RawInputFile*) {
 
 //striped mode functions
 void DataModeDTH::makeDirectoryEntries(std::vector<std::string> const& baseDirs,
-                                              std::vector<int> const& numSources,
-                                              std::vector<int> const& sourceIDs,
-                                              std::string const& sourceIdentifier,
-                                              std::string const& runDir) {
+                                       std::vector<int> const& numSources,
+                                       std::vector<int> const& sourceIDs,
+                                       std::string const& sourceIdentifier,
+                                       std::string const& runDir) {
   std::filesystem::path runDirP(runDir);
   for (auto& baseDir : baseDirs) {
     std::filesystem::path baseDirP(baseDir);
@@ -336,26 +330,28 @@ void DataModeDTH::makeDirectoryEntries(std::vector<std::string> const& baseDirs,
 
     for (auto sourceID : sourceIDs) {
       std::stringstream ss;
-      ss << "_" + sourceIdentifier << std::setfill('0') << std::setw(4) <<  std::to_string(sourceID);
+      ss << "_" + sourceIdentifier << std::setfill('0') << std::setw(4) << std::to_string(sourceID);
       buSourceStrings_.push_back(ss.str());
     }
 
     if (baseDirs.size() != numSources.size())
-      throw cms::Exception("DataModeDTH::makeDirectoryEntries") << "Number of defined directories not compatible with numSources list length";
+      throw cms::Exception("DataModeDTH::makeDirectoryEntries")
+          << "Number of defined directories not compatible with numSources list length";
 
     unsigned int sum = 0;
-    for (auto numSource: numSources) {
+    for (auto numSource : numSources) {
       buNumSources_.push_back(numSource);
       sum += numSource;
     }
 
     if (sum != sourceIDs.size())
-      throw cms::Exception("DataModeDTH::makeDirectoryEntries") << "Number of defined sources not consistent with the list of sourceIDs";
+      throw cms::Exception("DataModeDTH::makeDirectoryEntries")
+          << "Number of defined sources not consistent with the list of sourceIDs";
   }
 }
 
 std::pair<bool, std::vector<std::string>> DataModeDTH::defineAdditionalFiles(std::string const& primaryName,
-                                                                                    bool fileListMode) const {
+                                                                             bool fileListMode) const {
   //non-striped mode
   if (buPaths_.empty())
     return std::make_pair(true, std::vector<std::string>());
@@ -366,10 +362,11 @@ std::pair<bool, std::vector<std::string>> DataModeDTH::defineAdditionalFiles(std
   auto extpos = primaryName.rfind('.');
   auto indexpos = primaryName.find("_index");
   assert(indexpos != std::string::npos);
-  auto cutoff = primaryName.find('_', indexpos + 1); //search after index
-  if (cutoff == std::string::npos) cutoff = extpos; //no source
+  auto cutoff = primaryName.find('_', indexpos + 1);  //search after index
+  if (cutoff == std::string::npos)
+    cutoff = extpos;  //no source
   auto slashpos = primaryName.rfind('/', indexpos);
-  auto startoff = slashpos == std::string::npos ? 0 : slashpos + 1;//determine if directory path is returned
+  auto startoff = slashpos == std::string::npos ? 0 : slashpos + 1;  //determine if directory path is returned
 
   std::string primStem = primaryName.substr(startoff, cutoff - startoff);
   std::string ext = primaryName.substr(extpos);
@@ -377,15 +374,15 @@ std::pair<bool, std::vector<std::string>> DataModeDTH::defineAdditionalFiles(std
   if (!buSourceStrings_.empty()) {
     int counter = 0;
     for (size_t i = 0; i < buPaths_.size(); i++) {
-      for (size_t j = 0; j < (size_t) buNumSources_[i]; j++) {
+      for (size_t j = 0; j < (size_t)buNumSources_[i]; j++) {
         std::string replacement = buPaths_[i].generic_string() + ("/" + primStem + buSourceStrings_[counter] + ext);
         counter++;
-        if (i==0 && j==0) continue;
+        if (i == 0 && j == 0)
+          continue;
         additionalFiles.push_back(replacement);
       }
     }
-  }
-  else {
+  } else {
     auto fullpath = std::filesystem::path(primStem + ext);
     auto fullname = fullpath.filename();
     for (size_t i = 1; i < buPaths_.size(); i++) {
@@ -397,8 +394,8 @@ std::pair<bool, std::vector<std::string>> DataModeDTH::defineAdditionalFiles(std
 }
 
 //count events in raw file (in absence of file header) and return open file descriptor
-int DataModeDTH::eventCounterCallback(std::string const& name, int& rawFd, int64_t& totalSize, uint32_t sLS, bool& found) const {
-
+int DataModeDTH::eventCounterCallback(
+    std::string const& name, int& rawFd, int64_t& totalSize, uint32_t sLS, bool& found) const {
   uint32_t orbit_count = 0;
   uint32_t event_count = 0;
 
@@ -413,8 +410,8 @@ int DataModeDTH::eventCounterCallback(std::string const& name, int& rawFd, int64
   if ((rawFd = ::open(name.c_str(), O_RDONLY)) < 0) {
     assert(rawFd == -1);
     found = false;
-    edm::LogError("EvFDaqDirector")
-      << "parseFRDFileHeader - failed to open input file -: " << name << " : " << strerror(errno);
+    edm::LogError("EvFDaqDirector") << "parseFRDFileHeader - failed to open input file -: " << name << " : "
+                                    << strerror(errno);
     return -1;
   }
   found = true;
diff --git a/EventFilter/Utilities/src/EvFDaqDirector.cc b/EventFilter/Utilities/src/EvFDaqDirector.cc
index a3468564f65..df6e0ceade2 100644
--- a/EventFilter/Utilities/src/EvFDaqDirector.cc
+++ b/EventFilter/Utilities/src/EvFDaqDirector.cc
@@ -105,8 +105,7 @@ namespace evf {
     }
     if (useFileBroker_) {
       if (fileBrokerHost_.empty() || fileBrokerHost_ == "InValid")
-        throw cms::Exception("EvFDaqDirector")
-            << "fileBrokerHost parameter is not valid or empty";
+        throw cms::Exception("EvFDaqDirector") << "fileBrokerHost parameter is not valid or empty";
 
       resolver_ = std::make_unique<boost::asio::ip::tcp::resolver>(io_service_);
       query_ = std::make_unique<boost::asio::ip::tcp::resolver::query>(fileBrokerHost_, fileBrokerPort_);
@@ -264,8 +263,9 @@ namespace evf {
           std::filesystem::copy_file(hltSourceDirectory_ + "/fffParameters.jsn", tmphltdir + "/fffParameters.jsn");
           //also try to copy new DAQ parameters file
           try {
-          std::filesystem::copy_file(hltSourceDirectory_ + "/daqParameters.jsn", tmphltdir + "/daqParameters.jsn");
-          } catch (...) {}
+            std::filesystem::copy_file(hltSourceDirectory_ + "/daqParameters.jsn", tmphltdir + "/daqParameters.jsn");
+          } catch (...) {
+          }
 
           std::string optfiles[3] = {"hltinfo", "blacklist", "whitelist"};
           for (auto& optfile : optfiles) {
@@ -395,13 +395,15 @@ namespace evf {
     desc.addUntracked<std::vector<int>>("buBaseDirsNumStreams", std::vector<int>())
         ->setComment("Number of streams for each BU base ramdisk directories for multi-file DAQSource models");
     desc.addUntracked<std::vector<int>>("buBaseDirsStreamIDs", std::vector<int>())
-        ->setComment("SourceId, FEDId or sfbId combined list for each source in buBaseDirsNumStreams in identical order. If left empty, it can be inferred dynamically from input");
-    desc.addUntracked<std::string>("sourceIdentifier", std::string())->setComment("String prefix of IDs in raw filenames. None expected if left empty");
+        ->setComment(
+            "SourceId, FEDId or sfbId combined list for each source in buBaseDirsNumStreams in identical order. If "
+            "left empty, it can be inferred dynamically from input");
+    desc.addUntracked<std::string>("sourceIdentifier", std::string())
+        ->setComment("String prefix of IDs in raw filenames. None expected if left empty");
     desc.addUntracked<unsigned int>("runNumber", 0)->setComment("Run Number in ramdisk to open");
     desc.addUntracked<bool>("useFileBroker", false)
         ->setComment("Use BU file service to grab input data instead of NFS file locking");
-    desc.addUntracked<bool>("fileBrokerHostFromCfg", true)
-        ->setComment("Kept for compatibility with scripts");
+    desc.addUntracked<bool>("fileBrokerHostFromCfg", true)->setComment("Kept for compatibility with scripts");
     desc.addUntracked<std::string>("fileBrokerHost", "InValid")->setComment("BU file service host.");
     desc.addUntracked<std::string>("fileBrokerPort", "8080")->setComment("BU file service port");
     desc.addUntracked<bool>("fileBrokerKeepAlive", true)
@@ -1013,10 +1015,8 @@ namespace evf {
                                          bool requireHeader,
                                          bool retry,
                                          bool closeFile) {
-
     //skip opening file if rawFd is already intiialized
     if (rawFd == -1 && (rawFd = ::open(rawSourcePath.c_str(), O_RDONLY)) < 0) {
-
       if (retry) {
         edm::LogWarning("EvFDaqDirector")
             << "parseFRDFileHeader - failed to open input file -: " << rawSourcePath << " : " << strerror(errno);
@@ -1113,15 +1113,14 @@ namespace evf {
     return 0;  //OK
   }
 
-  bool EvFDaqDirector::hasFRDFileHeader(std::string const& rawPath, int& rawFd, bool &hasErr, bool closeFile) const {
-
-    auto retOK = [&](bool found=false, bool err=true) -> bool {
+  bool EvFDaqDirector::hasFRDFileHeader(std::string const& rawPath, int& rawFd, bool& hasErr, bool closeFile) const {
+    auto retOK = [&](bool found = false, bool err = true) -> bool {
       if (rawFd != -1) {
-        if (closeFile || !found) {//do not pass rawFd if not found
+        if (closeFile || !found) {  //do not pass rawFd if not found
           close(rawFd);
           rawFd = -1;
         } else {
-          lseek(rawFd, 0, SEEK_SET); //reset position
+          lseek(rawFd, 0, SEEK_SET);  //reset position
         }
       }
       return found;
@@ -1156,8 +1155,8 @@ namespace evf {
     uint16_t frd_version = getFRDFileHeaderVersion(fileId->id_, fileId->version_);
 
     if (frd_version == 0) {
-        //no header detected or unsupported version
-        return retOK(false);
+      //no header detected or unsupported version
+      return retOK(false);
     } else if (frd_version == 1) {
       //version 1 header
       if (!checkFileRead(hdr, rawFd, sizeof(FRDFileHeaderContent_v1), rawPath))
@@ -1190,7 +1189,6 @@ namespace evf {
     return retErr();
   }
 
-
   //TODO: sjould it be int& intfile ?
   bool EvFDaqDirector::checkFileRead(char* buf, int& infile, std::size_t buf_sz, std::string const& path) {
     if (infile == -1) {
@@ -1887,109 +1885,114 @@ namespace evf {
   }
 
   EvFDaqDirector::FileStatus EvFDaqDirector::discoverFile(unsigned int& fakeHttpStatus,
-                                                               bool& fakeServerError,
-                                                               uint32_t& serverLS,
-                                                               uint32_t& closedServerLS,
-                                                               std::string& nextFileJson,
-                                                               std::string& nextFileRaw,
-                                                               bool& rawHeader,
-                                                               int maxLS) {
+                                                          bool& fakeServerError,
+                                                          uint32_t& serverLS,
+                                                          uint32_t& closedServerLS,
+                                                          std::string& nextFileJson,
+                                                          std::string& nextFileRaw,
+                                                          bool& rawHeader,
+                                                          int maxLS) {
     fakeHttpStatus = 200;
     fakeServerError = false;
     //rawHeader = true; //assume header, let check be done and fallback to discover files if not
-    rawHeader = false; //assume header, let check be done and fallback to discover files if not
-    std::regex regex_ls("_ls([0-9]+)");  // Match _ls followed by digits
+    rawHeader = false;                         //assume header, let check be done and fallback to discover files if not
+    std::regex regex_ls("_ls([0-9]+)");        // Match _ls followed by digits
     std::regex regex_index("_index([0-9]+)");  // Match _ls followed by digits
 
     // Lambda function to extract the number after _ls
     auto extractIndexNumber = [&regex_index](const std::string& filename) -> int {
-        std::smatch match;
-        if (std::regex_search(filename, match, regex_index)) {
-            return std::stoi(match[1].str()); // Convert the matched number to an integer
-        }
-        return -1; // Return -1 if no match is found
+      std::smatch match;
+      if (std::regex_search(filename, match, regex_index)) {
+        return std::stoi(match[1].str());  // Convert the matched number to an integer
+      }
+      return -1;  // Return -1 if no match is found
     };
 
-
     // Lambda function to extract the number after _ls
     auto extractLumiSectionNumber = [&regex_ls](const std::string& filename) -> int {
-        std::smatch match;
-        if (std::regex_search(filename, match, regex_ls)) {
-            return std::stoi(match[1].str()); // Convert the matched number to an integer
-        }
-        return -1; // Return -1 if no match is found
+      std::smatch match;
+      if (std::regex_search(filename, match, regex_ls)) {
+        return std::stoi(match[1].str());  // Convert the matched number to an integer
+      }
+      return -1;  // Return -1 if no match is found
     };
 
     int maxClosedLS = 0;
 
     // Lambda to list and sort files by the number after _ls
     auto listSortedFilesByLS = [&](std::string const& path) -> std::vector<std::string> {
-        std::vector<std::string> filenames;
-        // Collect filenames
-        try {
-          for (const auto& entry : std::filesystem::directory_iterator(path)) {
-            if (std::filesystem::is_regular_file(entry.path())) { // Only files, not directories
-              auto fname = entry.path().filename().string();
-              //only files with run
-              if (!(fname.rfind("run", 0) == 0))
+      std::vector<std::string> filenames;
+      // Collect filenames
+      try {
+        for (const auto& entry : std::filesystem::directory_iterator(path)) {
+          if (std::filesystem::is_regular_file(entry.path())) {  // Only files, not directories
+            auto fname = entry.path().filename().string();
+            //only files with run
+            if (!(fname.rfind("run", 0) == 0))
+              continue;
+            if (fname.find("_EoR.jsn") != std::string::npos) {
+              filenames.push_back(entry.path().filename().string());
+              continue;
+            }
+            auto lumi = extractLumiSectionNumber(fname);
+            if (fname.find("_EoLS.jsn") != std::string::npos) {
+              if (lumi > (int)maxClosedLS)
+                maxClosedLS = lumi;
+              if (lumi >= (int)lastFileIdx_.first)
+                filenames.push_back(entry.path().filename().string());
+              continue;
+            }
+            if (!source_identifier_.empty()) {
+              if (fname.rfind(sourceid_first_) == std::string::npos)
                 continue;
-              if (fname.find("_EoR.jsn") != std::string::npos) {
+              //repeat search for EoR and EOLS with sourceid
+              if (fname.find("_EoR") != std::string::npos) {
                 filenames.push_back(entry.path().filename().string());
                 continue;
               }
-              auto lumi = extractLumiSectionNumber(fname);
-              if (fname.find("_EoLS.jsn") != std::string::npos) {
-                if (lumi > (int)maxClosedLS) maxClosedLS = lumi;
+              if (fname.find("_EoLS") != std::string::npos) {
+                if (lumi > (int)maxClosedLS)
+                  maxClosedLS = lumi;
                 if (lumi >= (int)lastFileIdx_.first)
                   filenames.push_back(entry.path().filename().string());
                 continue;
               }
-              if (!source_identifier_.empty()) {
-                if (fname.rfind(sourceid_first_) == std::string::npos)
-                  continue;
-                //repeat search for EoR and EOLS with sourceid
-                if (fname.find("_EoR") != std::string::npos) {
-                  filenames.push_back(entry.path().filename().string());
-                  continue;
-                }
-                if (fname.find("_EoLS") != std::string::npos) {
-                  if (lumi > (int)maxClosedLS) maxClosedLS = lumi;
-                  if (lumi >= (int)lastFileIdx_.first)
-                    filenames.push_back(entry.path().filename().string());
-                  continue;
-                }
-              }
-                //exclude json and similar, only raw file is parsed
-              if (fname.size() < 4 || fname.substr(fname.size()-4) != std::string(".raw"))
-                continue;
-              if (lumi >= (int)lastFileIdx_.first) {
-                if (extractIndexNumber(fname) >= lastFileIdx_.second) {
-                  filenames.push_back(entry.path().filename().string());
-                }
+            }
+            //exclude json and similar, only raw file is parsed
+            if (fname.size() < 4 || fname.substr(fname.size() - 4) != std::string(".raw"))
+              continue;
+            if (lumi >= (int)lastFileIdx_.first) {
+              if (extractIndexNumber(fname) >= lastFileIdx_.second) {
+                filenames.push_back(entry.path().filename().string());
               }
             }
           }
+        }
 
-          // Sort filenames based on the extracted number after _ls
-          std::sort(filenames.begin(), filenames.end(), [&](const std::string& a, const std::string& b) {
-            if (a.find("_EoR") != std::string::npos) return false;
-            if (b.find("_EoR") != std::string::npos) return true;
-            auto ls_a = extractLumiSectionNumber(a);
-            auto ls_b = extractLumiSectionNumber(b);
-            if (ls_a == ls_b) {
-              if (a.find("_EoLS") != std::string::npos) return false;
-              if (b.find("_EoLS") != std::string::npos) return true;
-              return extractIndexNumber(a) < extractIndexNumber(b);
-            }
-            return extractLumiSectionNumber(a) < extractLumiSectionNumber(b);
-          });
+        // Sort filenames based on the extracted number after _ls
+        std::sort(filenames.begin(), filenames.end(), [&](const std::string& a, const std::string& b) {
+          if (a.find("_EoR") != std::string::npos)
+            return false;
+          if (b.find("_EoR") != std::string::npos)
+            return true;
+          auto ls_a = extractLumiSectionNumber(a);
+          auto ls_b = extractLumiSectionNumber(b);
+          if (ls_a == ls_b) {
+            if (a.find("_EoLS") != std::string::npos)
+              return false;
+            if (b.find("_EoLS") != std::string::npos)
+              return true;
+            return extractIndexNumber(a) < extractIndexNumber(b);
+          }
+          return extractLumiSectionNumber(a) < extractLumiSectionNumber(b);
+        });
 
-        } catch (const std::filesystem::filesystem_error& e) {
-            edm::LogWarning("EvFDaqDirector") << "Error accessing directory: " << e.what();
-            fakeServerError = true;
-        }
+      } catch (const std::filesystem::filesystem_error& e) {
+        edm::LogWarning("EvFDaqDirector") << "Error accessing directory: " << e.what();
+        fakeServerError = true;
+      }
 
-        return filenames;
+      return filenames;
     };
 
     std::function<EvFDaqDirector::FileStatus(bool)> findNextFile = [&](bool recheck) -> EvFDaqDirector::FileStatus {
@@ -1999,16 +2002,17 @@ namespace evf {
       if (files.empty())
         return noFile;
 
-      for (auto const& name: files) {
+      for (auto const& name : files) {
         auto nextLS = extractLumiSectionNumber(name);
-        LogDebug("EvFDaqDirector") << "next file is:" << name << " serverLS:" << serverLS << " closedSrvLS:" << closedServerLS << " next LS: " << nextLS;
+        LogDebug("EvFDaqDirector") << "next file is:" << name << " serverLS:" << serverLS
+                                   << " closedSrvLS:" << closedServerLS << " next LS: " << nextLS;
 
         assert(nextLS >= 0);
         if (nextLS == 0) {
           //EOR
           //TODO: rescan
           if (recheck)
-              return findNextFile(false);
+            return findNextFile(false);
           closedServerLS = maxClosedLS;
           return runEnded;
         }
@@ -2017,7 +2021,7 @@ namespace evf {
           //received EOLS, open next LS
           //TODO: rescan
           if (recheck)
-              return findNextFile(false);
+            return findNextFile(false);
           //assert((int)serverLS <= nextLS);
           serverLS = nextLS + 1;
           lastFileIdx_.first = serverLS;
@@ -2034,13 +2038,19 @@ namespace evf {
           std::filesystem::create_directory(bu_run_dir_ + fileprefix);
         }
         std::filesystem::path p = name;
-        auto nextFileRawTmp = fmt::format("{}{}{}_{}_pid{}{}", bu_run_dir_, fileprefix, p.stem().string(), hostname_, getpid(), p.extension().string());
+        auto nextFileRawTmp = fmt::format("{}{}{}_{}_pid{}{}",
+                                          bu_run_dir_,
+                                          fileprefix,
+                                          p.stem().string(),
+                                          hostname_,
+                                          getpid(),
+                                          p.extension().string());
         try {
           //grab file if possible
           std::filesystem::rename(rawpath, nextFileRawTmp);
           //apply changes
           nextFileRaw = nextFileRawTmp;
-          serverLS = nextLS;//if changed
+          serverLS = nextLS;  //if changed
           closedServerLS = nextLS - 1;
 
           //update last info
@@ -2052,16 +2062,16 @@ namespace evf {
           return newFile;
         } catch (const std::filesystem::filesystem_error& e) {
           if (e.code().value() == ESTALE) {
-             edm::LogWarning("EvFDaqDirector") << "Filesystem ESTALE error:" << e.what() << " for source file:" << rawpath;
-             continue; //grabbed? try next file
-          }
-          else if (e.code() == std::errc::no_such_file_or_directory) {
+            edm::LogWarning("EvFDaqDirector")
+                << "Filesystem ESTALE error:" << e.what() << " for source file:" << rawpath;
+            continue;  //grabbed? try next file
+          } else if (e.code() == std::errc::no_such_file_or_directory) {
             //try next raw file in case other process grabbed it
             continue;
             //if (recheck)
             //  return findNextFile(false);
           } else
-             edm::LogWarning("EvFDaqDirector") << "Filesystem error: " << e.what();
+            edm::LogWarning("EvFDaqDirector") << "Filesystem error: " << e.what();
 
           fakeServerError = true;
           return noFile;
@@ -2181,7 +2191,7 @@ namespace evf {
       } else if (eventCounter) {
         //there is no header: then try to use model to count events
         serverEventsInNewFile = eventCounter(nextFileRaw, rawFd, fileSizeFromMetadata, serverLS, fileFound);
-      }else {
+      } else {
         //or look for json file (deprecated)
         serverEventsInNewFile = grabNextJsonFile(nextFileJson, nextFileRaw, fileSizeFromMetadata, fileFound);
       }
