Produce per-detector ctf dictionaries

shahor02 · shahor02 · commit dfe1eaf02b5f · 2022-04-30T15:23:24.000+04:00
on top of the single file with tree-based dictionaries. These per-detector dictionaries
are ready to be uploaded at the CCDB.
diff --git a/Common/Utils/src/FileSystemUtils.cxx b/Common/Utils/src/FileSystemUtils.cxx
@@ -57,7 +57,7 @@ std::vector<std::string> listFiles(std::string const& searchpattern)
 
 void createDirectoriesIfAbsent(std::string const& path)
 {
-  if (!std::filesystem::create_directories(path) && !std::filesystem::is_directory(path)) {
+  if (!path.empty() && !std::filesystem::create_directories(path) && !std::filesystem::is_directory(path)) {
     throw std::runtime_error(fmt::format("Failed to create {} directory", path));
   }
 }
diff --git a/DataFormats/Detectors/Common/src/CTFDictHeader.cxx b/DataFormats/Detectors/Common/src/CTFDictHeader.cxx
@@ -25,6 +25,6 @@ std::string CTFDictHeader::asString() const
   std::time_t temp = dictTimeStamp;
   std::tm* t = std::gmtime(&temp);
   std::stringstream ss;
-  ss << "CTF Dict for " << det.getName() << ", v" << int(majorVersion) << '.' << int(minorVersion) << " from " << std::put_time(t, "%Y-%m-%d %I:%M:%S %p");
+  ss << det.getName() << " CTF dictionary v" << int(majorVersion) << '.' << int(minorVersion) << '.' << dictTimeStamp << " (" << std::put_time(t, "%d/%m/%y %H:%M:%S") << " UTC)";
   return ss.str();
 }
diff --git a/Detectors/Base/include/DetectorsBase/CTFCoderBase.h b/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
@@ -53,7 +53,7 @@ class CTFCoderBase
   std::vector<char> readDictionaryFromFile(const std::string& dictPath, bool mayFail = false);
 
   template <typename CTF>
-  void createCodersFromFile(const std::string& dictPath, o2::ctf::CTFCoderBase::OpType op);
+  void createCodersFromFile(const std::string& dictPath, o2::ctf::CTFCoderBase::OpType op, bool mayFail = false);
 
   template <typename S>
   void createCoder(OpType op, const o2::rans::RenormedFrequencyTable& renormedFrequencyTable, int slot)
@@ -123,9 +123,8 @@ bool CTFCoderBase::readFromTree(TTree& tree, const std::string brname, T& dest,
 
 ///________________________________
 template <typename CTF>
-void CTFCoderBase::createCodersFromFile(const std::string& dictPath, o2::ctf::CTFCoderBase::OpType op)
+void CTFCoderBase::createCodersFromFile(const std::string& dictPath, o2::ctf::CTFCoderBase::OpType op, bool mayFail)
 {
-  bool mayFail = true;
   auto buff = readDictionaryFromFile<CTF>(dictPath, mayFail);
   if (!buff.size()) {
     if (mayFail) {
diff --git a/Detectors/CTF/README.md b/Detectors/CTF/README.md
@@ -40,10 +40,9 @@ By default only CTFs will written. If the upstream entropy compression is perfor
 `--output-type both` (will store both dictionaries and CTF). This is the only valid mode for dictionaries creation (if one requests dictionary creation but the compression was done with external dictionaries, the newly created dictionaries will be empty).
 In the dictionaries creation mode their data are accumulated over all CTFs procssed. User may request periodic (and incremental) saving of dictionaries after every `N` TFs processed by passing `--save-dict-after <N>` option.
 
-Option `--ctf-dict-dir <dir>` can be provided to indicate the (existing) directory where the dictionary will be stored.
+Option `--ctf-dict-dir <dir>` can be provided to indicate the directory where the dictionary will be stored.
 
-The external dictionaries created by the `o2-ctf-writer-workflow` containes a TTree (one for all participating detectos or single file per detector if `--dict-per-det` was provided). Since the TTrees cannot be used with CcdbAPI, one can
-run the macro `O2/Detectors/CTF/utils/CTFdict2CCDBfiles.C` (installed to $O2_ROOT/share/macro/CTFdict2CCDBfiles.C) which extracts the dictionary for every detector into separate file containing plain `vector<char>`. These files can be directly
+The external dictionaries created by the `o2-ctf-writer-workflow` containes a TTree (one for all participating detectos) and separate dictionaries per detector which can be uploaded to the CCDB. The per-detector dictionaries compatible with CCDB can be also extracted from the common TTree-based dictionary file using the macro `O2/Detectors/CTF/utils/CTFdict2CCDBfiles.C` (installed to $O2_ROOT/share/macro/CTFdict2CCDBfiles.C) which extracts the dictionary for every detector into separate file containing plain `vector<char>`. These per-detector files can be directly
 uploaded to CCDB and accessed via `CcdbAPI` (the reference of the vector should be provided to corresponding detector CTFCoder::createCoders method to build the run-time dictionary). These files can be also used as per-detector command-line
 parameters, on the same footing as tree-based dictionaries, e.g.
 ```
diff --git a/Detectors/CTF/utils/CTFdict2CCDBfiles.C b/Detectors/CTF/utils/CTFdict2CCDBfiles.C
@@ -55,6 +55,7 @@ void extractDictionary(TTree& tree, o2::detectors::DetID det, DetID::mask_t detM
   std::string outName = fmt::format("ctfdict_{}_v{}.{}_{}.root", det.getName(), int(dictHeader.majorVersion), int(dictHeader.minorVersion), dictHeader.dictTimeStamp);
   TFile flout(outName.c_str(), "recreate");
   flout.WriteObject(&bufVec, o2::base::NameConf::CCDBOBJECT.data());
+  flout.WriteObject(&dictHeader, fmt::format("ctf_dict_header_{}", det.getName()).c_str());
   flout.Close();
   LOG(info) << "Wrote " << dictHeader.asString() << " to " << outName;
 }
diff --git a/Detectors/CTF/workflow/src/CTFWriterSpec.cxx b/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
@@ -103,9 +103,6 @@ class CTFWriterSpec : public o2::framework::Task
   template <typename C>
   void storeDictionary(DetID det, CTFHeader& header);
   void storeDictionaries();
-  void prepareDictionaryTreeAndFile(DetID det);
-  void closeDictionaryTreeAndFile(CTFHeader& header);
-  std::string dictionaryFileName(const std::string& detName = "");
   void closeTFTreeAndFile();
   void prepareTFTreeAndFile(const o2::header::DataHeader* dh);
   size_t estimateCTFSize(ProcessingContext& pc);
@@ -118,19 +115,21 @@ class CTFWriterSpec : public o2::framework::Task
   bool mFinalized = false;
   bool mWriteCTF = true;
   bool mCreateDict = false;
-  bool mDictPerDetector = false;
   bool mCreateRunEnvDir = true;
   bool mStoreMetaFile = false;
   int mVerbosity = 0;
   int mSaveDictAfter = 0; // if positive and mWriteCTF==true, save dictionary after each mSaveDictAfter TFs processed
   int mFlagMinDet = 1;    // append list of detectors to LHC period if their number is <= mFlagMinDet
+  uint32_t mPrevDictTimeStamp = 0; // timestamp of the previously stored dictionary
+  uint32_t mDictTimeStamp = 0;     // timestamp of the currently stored dictionary
   uint64_t mRun = 0;
   size_t mMinSize = 0;               // if > 0, accumulate CTFs in the same tree until the total size exceeds this minimum
   size_t mMaxSize = 0;               // if > MinSize, and accumulated size will exceed this value, stop accumulation (even if mMinSize is not reached)
   size_t mChkSize = 0;               // if > 0 and fallback storage provided, reserve this size per CTF file in production on primary storage
   size_t mAccCTFSize = 0;            // so far accumulated size (if any)
   size_t mCurrCTFSize = 0;           // size of currently processed CTF
   size_t mNCTF = 0;                  // total number of CTFs written
+  size_t mNCTFPrevDict = 0;          // total number of CTFs used for previous dictionary version
   size_t mNAccCTF = 0;               // total number of CTFs accumulated in the current file
   size_t mCTFAutoSave = 0;           // if > 0, autosave after so many TFs
   size_t mNCTFFiles = 0;             // total number of CTF files written
@@ -151,7 +150,6 @@ class CTFWriterSpec : public o2::framework::Task
   int mLockFD = -1;
   std::unique_ptr<TFile> mCTFFileOut;
   std::unique_ptr<TTree> mCTFTreeOut;
-  std::unique_ptr<o2::dataformats::FileMetaData> mCTFFileMetaData;
 
   std::unique_ptr<TFile> mDictFileOut; // file to store dictionary
   std::unique_ptr<TTree> mDictTreeOut; // tree to store dictionary
@@ -181,7 +179,6 @@ CTFWriterSpec::CTFWriterSpec(DetID::mask_t dm, uint64_t r, const std::string& ou
 //___________________________________________________________________
 void CTFWriterSpec::init(InitContext& ic)
 {
-  mDictPerDetector = ic.options().get<bool>("dict-per-det");
   // auto outmode = ic.options().get<std::string>("output-type"); // RS FIXME once global/local options clash is solved, --output-type will become device option
   auto outmode = mOutputType;
   if (outmode == "ctf") {
@@ -230,18 +227,11 @@ void CTFWriterSpec::init(InitContext& ic)
   o2::utils::createDirectoriesIfAbsent(LOCKFileDir);
 
   if (mCreateDict) { // make sure that there is no local dictonary
-    for (int id = 0; id < DetID::nDetectors; id++) {
-      DetID det(id);
-      if (isPresent(det)) {
-        auto dictName = dictionaryFileName(det.getName());
-        if (std::filesystem::exists(dictName)) {
-          throw std::runtime_error(o2::utils::Str::concat_string("CTF dictionary creation is requested but ", dictName, " already exists, remove it!"));
-        }
-        if (!mDictPerDetector) {
-          break; // no point in checking further
-        }
-      }
+    std::string dictFileName = fmt::format("{}{}.root", mDictDir, o2::base::NameConf::CTFDICT);
+    if (std::filesystem::exists(dictFileName)) {
+      throw std::runtime_error(o2::utils::Str::concat_string("CTF dictionary creation is requested but ", dictFileName, " already exists, remove it!"));
     }
+    o2::utils::createDirectoriesIfAbsent(mDictDir);
   }
 }
 
@@ -269,7 +259,6 @@ size_t CTFWriterSpec::processDet(o2::framework::ProcessingContext& pc, DetID det
     if (!mHeaders[det]) { // store 1st header
       mHeaders[det] = ctfImage.cloneHeader();
       auto& hb = *static_cast<o2::ctf::CTFDictHeader*>(mHeaders[det].get());
-      hb.dictTimeStamp = uint32_t(std::time(nullptr));
       hb.det = det;
     }
     for (int ib = 0; ib < C::getNBlocks(); ib++) {
@@ -291,28 +280,38 @@ size_t CTFWriterSpec::processDet(o2::framework::ProcessingContext& pc, DetID det
 template <typename C>
 void CTFWriterSpec::storeDictionary(DetID det, CTFHeader& header)
 {
+  // create vector whose data contains dictionary in CTF format (EncodedBlock)
   if (!isPresent(det) || !mFreqsAccumulation[det].size()) {
     return;
   }
-  prepareDictionaryTreeAndFile(det);
-  // create vector whose data contains dictionary in CTF format (EncodedBlock)
   auto dictBlocks = C::createDictionaryBlocks(mFreqsAccumulation[det], mFreqsMetaData[det]);
   auto& h = C::get(dictBlocks.data())->getHeader();
   h = *reinterpret_cast<typename std::remove_reference<decltype(h)>::type*>(mHeaders[det].get());
   auto& hb = static_cast<o2::ctf::CTFDictHeader&>(h);
   hb = *static_cast<const o2::ctf::CTFDictHeader*>(mHeaders[det].get());
+  hb.dictTimeStamp = mDictTimeStamp;
+
+  auto getFileName = [this, det, &hb](bool curr) {
+    return fmt::format("{}{}_{}_v{}.{}_{}_{}.root", this->mDictDir, o2::base::NameConf::CTFDICT, det.getName(), int(hb.majorVersion), int(hb.minorVersion),
+                       curr ? this->mDictTimeStamp : this->mPrevDictTimeStamp, curr ? this->mNCTF : this->mNCTFPrevDict);
+  };
 
   C::get(dictBlocks.data())->print(o2::utils::Str::concat_string("Storing dictionary for ", det.getName(), ": "));
-  C::get(dictBlocks.data())->appendToTree(*mDictTreeOut.get(), det.getName()); // cast to EncodedBlock
-  //  mFreqsAccumulation[det].clear();
-  //  mFreqsMetaData[det].clear();
-  if (mDictPerDetector) {
-    header.detectors.reset();
+  auto outName = getFileName(true);
+  TFile flout(outName.c_str(), "recreate");
+  flout.WriteObject(&dictBlocks, o2::base::NameConf::CCDBOBJECT.data());
+  flout.WriteObject(&hb, fmt::format("ctf_dict_header_{}", det.getName()).c_str());
+  flout.Close();
+  LOGP(info, "Saved {} with {} TFs to {}", hb.asString(), mNCTF, outName);
+  if (mPrevDictTimeStamp) {
+    auto outNamePrev = getFileName(false);
+    if (std::filesystem::exists(outNamePrev)) {
+      std::filesystem::remove(outNamePrev);
+      LOGP(info, "Removed previous dictionary version {}", outNamePrev);
+    }
   }
+  C::get(dictBlocks.data())->appendToTree(*mDictTreeOut.get(), det.getName()); // cast to EncodedBlock and attach to dictionaries tree
   header.detectors.set(det);
-  if (mDictPerDetector) {
-    closeDictionaryTreeAndFile(header);
-  }
 }
 
 //___________________________________________________________________
@@ -495,16 +494,15 @@ void CTFWriterSpec::prepareTFTreeAndFile(const o2::header::DataHeader* dh)
     }
     if (mCreateRunEnvDir && !mEnvironmentID.empty()) {
       ctfDir += fmt::format("{}_{}/", mEnvironmentID, mRun);
-      o2::utils::createDirectoriesIfAbsent(ctfDir);
-      LOG(info) << "Created {} directory for CTFs output" << ctfDir;
+      if (!ctfDir.empty()) {
+        o2::utils::createDirectoriesIfAbsent(ctfDir);
+        LOGP(info, "Created {} directory for CTFs output", ctfDir);
+      }
     }
     mCurrentCTFFileName = o2::base::NameConf::getCTFFileName(mRun, dh->firstTForbit, dh->tfCounter);
     mCurrentCTFFileNameFull = fmt::format("{}{}", ctfDir, mCurrentCTFFileName);
     mCTFFileOut.reset(TFile::Open(fmt::format("{}{}", mCurrentCTFFileNameFull, TMPFileEnding).c_str(), "recreate")); // to prevent premature external usage, use temporary name
     mCTFTreeOut = std::make_unique<TTree>(std::string(o2::base::NameConf::CTFTREENAME).c_str(), "O2 CTF tree");
-    if (mStoreMetaFile) {
-      mCTFFileMetaData = std::make_unique<o2::dataformats::FileMetaData>();
-    }
 
     mNCTFFiles++;
   }
@@ -525,16 +523,17 @@ void CTFWriterSpec::closeTFTreeAndFile()
       }
       // write CTF file metaFile data
       if (mStoreMetaFile) {
-        mCTFFileMetaData->fillFileData(mCurrentCTFFileNameFull);
-        mCTFFileMetaData->run = mRun;
-        mCTFFileMetaData->LHCPeriod = mLHCPeriod;
-        mCTFFileMetaData->type = "raw";
-        mCTFFileMetaData->priority = "high";
+        o2::dataformats::FileMetaData ctfMetaData;
+        ctfMetaData.fillFileData(mCurrentCTFFileNameFull);
+        ctfMetaData.run = mRun;
+        ctfMetaData.LHCPeriod = mLHCPeriod;
+        ctfMetaData.type = "raw";
+        ctfMetaData.priority = "high";
         auto metaFileNameTmp = fmt::format("{}{}.tmp", mCTFMetaFileDir, mCurrentCTFFileName);
         auto metaFileName = fmt::format("{}{}.done", mCTFMetaFileDir, mCurrentCTFFileName);
         try {
           std::ofstream metaFileOut(metaFileNameTmp);
-          metaFileOut << *mCTFFileMetaData.get();
+          metaFileOut << ctfMetaData;
           metaFileOut << "TFOrbits: ";
           for (size_t i = 0; i < mTFOrbits.size(); i++) {
             metaFileOut << fmt::format("{}{}", i ? ", " : "", mTFOrbits[i]);
@@ -545,7 +544,6 @@ void CTFWriterSpec::closeTFTreeAndFile()
         } catch (std::exception const& e) {
           LOG(error) << "Failed to store CTF meta data file " << metaFileName << ", reason: " << e.what();
         }
-        mCTFFileMetaData.reset();
       }
     } catch (std::exception const& e) {
       LOG(error) << "Failed to finalize CTF file " << mCurrentCTFFileNameFull << ", reason: " << e.what();
@@ -557,39 +555,18 @@ void CTFWriterSpec::closeTFTreeAndFile()
   }
 }
 
-//___________________________________________________________________
-void CTFWriterSpec::prepareDictionaryTreeAndFile(DetID det)
-{
-  if (mDictPerDetector) {
-    if (mDictTreeOut) {
-      mDictTreeOut->SetEntries(1);
-      mDictTreeOut->Write();
-      mDictTreeOut.reset();
-      mDictFileOut.reset();
-    }
-  }
-  if (!mDictTreeOut) {
-    mDictFileOut.reset(TFile::Open(dictionaryFileName(det.getName()).c_str(), "recreate"));
-    mDictTreeOut = std::make_unique<TTree>(std::string(o2::base::NameConf::CTFDICT).c_str(), "O2 CTF dictionary");
-  }
-}
-
-//___________________________________________________________________
-std::string CTFWriterSpec::dictionaryFileName(const std::string& detName)
-{
-  if (mDictPerDetector) {
-    if (detName.empty()) {
-      throw std::runtime_error("Per-detector dictionary files are requested but detector name is not provided");
-    }
-    return o2::utils::Str::concat_string(mDictDir, detName, '_', o2::base::NameConf::CTFDICT, ".root");
-  } else {
-    return o2::utils::Str::concat_string(mDictDir, o2::base::NameConf::CTFDICT, ".root");
-  }
-}
-
 //___________________________________________________________________
 void CTFWriterSpec::storeDictionaries()
 {
+  // monolitic dictionary in tree format
+  mDictTimeStamp = uint32_t(std::time(nullptr));
+  auto getFileName = [this](bool curr) {
+    return fmt::format("{}{}_{}_{}.root", this->mDictDir, o2::base::NameConf::CTFDICT, curr ? this->mDictTimeStamp : this->mPrevDictTimeStamp, curr ? this->mNCTF : this->mNCTFPrevDict);
+  };
+  auto dictFileName = getFileName(true);
+  mDictFileOut.reset(TFile::Open(dictFileName.c_str(), "recreate"));
+  mDictTreeOut = std::make_unique<TTree>(std::string(o2::base::NameConf::CTFDICT).c_str(), "O2 CTF dictionary");
+
   CTFHeader header{mRun, uint32_t(mNCTF)};
   storeDictionary<o2::itsmft::CTF>(DetID::ITS, header);
   storeDictionary<o2::itsmft::CTF>(DetID::MFT, header);
@@ -607,25 +584,27 @@ void CTFWriterSpec::storeDictionaries()
   storeDictionary<o2::zdc::CTF>(DetID::ZDC, header);
   storeDictionary<o2::hmpid::CTF>(DetID::HMP, header);
   storeDictionary<o2::ctp::CTF>(DetID::CTP, header);
-
-  // close remnants
-  if (mDictTreeOut) {
-    closeDictionaryTreeAndFile(header);
-  }
-  LOG(info) << "Saved CTF dictionary after " << mNCTF << " TFs processed";
-}
-
-//___________________________________________________________________
-void CTFWriterSpec::closeDictionaryTreeAndFile(CTFHeader& header)
-{
-  if (mDictTreeOut) {
-    mDictFileOut->cd();
-    appendToTree(*mDictTreeOut.get(), "CTFHeader", header);
-    mDictTreeOut->SetEntries(1);
-    mDictTreeOut->Write(mDictTreeOut->GetName(), TObject::kSingleKey);
-    mDictTreeOut.reset();
-    mDictFileOut.reset();
+  mDictFileOut->cd();
+  appendToTree(*mDictTreeOut.get(), "CTFHeader", header);
+  mDictTreeOut->SetEntries(1);
+  mDictTreeOut->Write(mDictTreeOut->GetName(), TObject::kSingleKey);
+  mDictTreeOut.reset();
+  mDictFileOut.reset();
+  std::string dictFileNameLnk = fmt::format("{}{}.root", mDictDir, o2::base::NameConf::CTFDICT);
+  if (std::filesystem::exists(dictFileNameLnk)) {
+    std::filesystem::remove(dictFileNameLnk);
+  }
+  std::filesystem::create_symlink(dictFileName, dictFileNameLnk);
+  LOGP(info, "Saved CTF dictionaries tree with {} TFs to {} and linked to {}", mNCTF, dictFileName, dictFileNameLnk);
+  if (mPrevDictTimeStamp) {
+    auto dictFileNamePrev = getFileName(false);
+    if (std::filesystem::exists(dictFileNamePrev)) {
+      std::filesystem::remove(dictFileNamePrev);
+      LOGP(info, "Removed previous dictionary version {}", dictFileNamePrev);
+    }
   }
+  mNCTFPrevDict = mNCTF;
+  mPrevDictTimeStamp = mDictTimeStamp;
 }
 
 //___________________________________________________________________
@@ -729,7 +708,6 @@ DataProcessorSpec getCTFWriterSpec(DetID::mask_t dets, uint64_t run, const std::
             {"save-ctf-after", VariantType::Int, 0, {"if > 0, autosave CTF tree with multiple CTFs after every N CTFs"}},
             {"save-dict-after", VariantType::Int, 0, {"if > 0, in dictionary generation mode save it dictionary after certain number of TFs processed"}},
             {"ctf-dict-dir", VariantType::String, "none", {"CTF dictionary directory, must exist"}},
-            {"dict-per-det", VariantType::Bool, false, {"create dictionary file per detector"}},
             {"output-dir", VariantType::String, "none", {"CTF output directory, must exist"}},
             {"output-dir-alt", VariantType::String, "/dev/null", {"Alternative CTF output directory, must exist (if not /dev/null)"}},
             {"meta-output-dir", VariantType::String, "/dev/null", {"CTF metadata output directory, must exist (if not /dev/null)"}},

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ std::vector<std::string> listFiles(std::string const& searchpattern)`
`57`	`57`
`58`	`58`	`void createDirectoriesIfAbsent(std::string const& path)`
`59`	`59`	`{`
`60`		`- if (!std::filesystem::create_directories(path) && !std::filesystem::is_directory(path)) {`
	`60`	`+ if (!path.empty() && !std::filesystem::create_directories(path) && !std::filesystem::is_directory(path)) {`
`61`	`61`	`throw std::runtime_error(fmt::format("Failed to create {} directory", path));`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,6 @@ std::string CTFDictHeader::asString() const`
`25`	`25`	`std::time_t temp = dictTimeStamp;`
`26`	`26`	`std::tm* t = std::gmtime(&temp);`
`27`	`27`	`std::stringstream ss;`
`28`		`- ss << "CTF Dict for " << det.getName() << ", v" << int(majorVersion) << '.' << int(minorVersion) << " from " << std::put_time(t, "%Y-%m-%d %I:%M:%S %p");`
	`28`	`+ ss << det.getName() << " CTF dictionary v" << int(majorVersion) << '.' << int(minorVersion) << '.' << dictTimeStamp << " (" << std::put_time(t, "%d/%m/%y %H:%M:%S") << " UTC)";`
`29`	`29`	`return ss.str();`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ void extractDictionary(TTree& tree, o2::detectors::DetID det, DetID::mask_t detM`
`55`	`55`	`std::string outName = fmt::format("ctfdict_{}_v{}.{}_{}.root", det.getName(), int(dictHeader.majorVersion), int(dictHeader.minorVersion), dictHeader.dictTimeStamp);`
`56`	`56`	`TFile flout(outName.c_str(), "recreate");`
`57`	`57`	`flout.WriteObject(&bufVec, o2::base::NameConf::CCDBOBJECT.data());`
	`58`	`+ flout.WriteObject(&dictHeader, fmt::format("ctf_dict_header_{}", det.getName()).c_str());`
`58`	`59`	`flout.Close();`
`59`	`60`	`LOG(info) << "Wrote " << dictHeader.asString() << " to " << outName;`
`60`	`61`	`}`