Added gaussian dynamic precision

Author: tubagundem

Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h

@@ -28,10 +28,11 @@
 namespace o2::tpc
 {
 
-struct CMVPerTF;         // forward declaration
-struct CMVPerTFSparse;   // forward declaration
-struct CMVPerTFHuffman;  // forward declaration
-struct CMVPerTFCombined; // forward declaration
+struct CMVPerTF;          // forward declaration
+struct CMVPerTFSparse;    // forward declaration
+struct CMVPerTFHuffman;   // forward declaration
+struct CMVPerTFCombined;  // forward declaration
+struct CMVPerTFQuantized; // forward declaration
 
 /// Delta+zigzag+varint compressed CMV data for one TF across all CRUs
 /// Produced by CMVPerTF::compressVarint(), restored with decompress()
@@ -108,7 +109,7 @@ struct CMVPerTFHuffman {
 
 /// Hybrid sparse+compressed-value encoding for one TF across all CRUs
 ///
-/// Non-zero positions are stored as sparse varint deltas (same as CMVPerTFSparse).
+/// Non-zero positions are stored as sparse varint deltas (same as CMVPerTFSparse)
 /// The remaining non-zero values are encoded according to mValueMode:
 ///
 ///   Mode 0  raw uint16_t     — identical value encoding to CMVPerTFSparse
@@ -135,6 +136,31 @@ struct CMVPerTFCombined {
   ClassDefNV(CMVPerTFCombined, 1)
 };
 
+/// Sparse positions + quantized-value symbols for one TF across all CRUs
+///
+/// Non-zero positions are stored as sparse varint deltas.
+/// The corresponding values are encoded as quantized signed symbols:
+///   Mode 0  raw symbols      — 4-byte LE uint32 per symbol
+///   Mode 1  varint symbols   — varint(symbol)
+///   Mode 2  Huffman symbols  — canonical Huffman over symbol stream
+/// Quantized symbols represent decimal-style values below the internally derived full-precision cutoff
+/// and exact raw signed I8F7 values above it.
+struct CMVPerTFQuantized {
+  uint32_t firstOrbit{0}; ///< First orbit of this TF
+  uint16_t firstBC{0};    ///< First bunch crossing of this TF
+  uint8_t mValueMode{0};  ///< 0 = raw symbols, 1 = varint symbols, 2 = Huffman symbols
+
+  std::vector<uint8_t> mData; ///< Encoded payload
+
+  /// Restore nearest raw-I8F7 values into *cmv (must not be null)
+  void decompress(CMVPerTF* cmv) const;
+
+  /// Restore exact quantized float values into `values`, sized to CRU::MaxCRU * cmv::NTimeBinsPerTF
+  void decompressToFloatBuffer(std::vector<float>& values) const;
+
+  ClassDefNV(CMVPerTFQuantized, 1)
+};
+
 /// CMV data for one TF across all CRUs
 /// Raw 16-bit CMV values are stored in a flat C array indexed as [cru * NTimeBinsPerTF + timeBin]
 /// CRU::MaxCRU and cmv::NTimeBinsPerTF are compile-time constants, so no dynamic allocation is needed
@@ -166,12 +192,24 @@ struct CMVPerTF {
   /// threshold=0 rounding is not applied
   void roundToIntegers(uint16_t threshold);
 
+  /// Quantise |v| with a Gaussian-CDF recovery profile:
+  /// coarse decimal-style precision below and around mean, then a smooth return to the
+  /// full native I8F7 precision as the magnitude increases with width sigma
+  void trimGaussianPrecision(float mean, float sigma);
+
   /// Compress this object into a CMVPerTFVarint using delta+zigzag+varint encoding
   CMVPerTFVarint compressVarint() const;
 
   /// Compress this object into a CMVPerTFSparse storing only non-zero timebins
   CMVPerTFSparse compressSparse() const;
 
+  /// Dedicated sparse + quantized-value compression
+  /// valueMode:
+  ///   0 = raw symbol stream
+  ///   1 = varint symbol stream
+  ///   2 = Huffman symbol stream
+  CMVPerTFQuantized compressQuantized(uint8_t valueMode = 0, float quantizationMean = 1.f, float quantizationSigma = 0.f) const;
+
   /// Hybrid sparse+compressed-value compression
   /// Positions encoded as sparse varint deltas; values encoded according to valueMode:
   ///   0 = raw uint16_t  (same as compressSparse, no additional gain)
@@ -189,9 +227,10 @@ struct CMVPerTF {
   static void writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree);
 
  private:
-  static int32_t cmvToSigned(uint16_t raw);                                ///< Sign-magnitude uint16_t → signed integer
-  static uint32_t zigzagEncode(int32_t value);                             ///< Zigzag encode
-  static void encodeVarintInto(uint32_t value, std::vector<uint8_t>& out); ///< Varint encode
+  static int32_t cmvToSigned(uint16_t raw);                                                              ///< Sign-magnitude uint16_t → signed integer
+  static uint16_t quantizeBelowThreshold(uint16_t raw, float quantizationMean, float quantizationSigma); ///< Quantise sub-threshold values with a Gaussian-shaped recovery to full precision
+  static uint32_t zigzagEncode(int32_t value);                                                           ///< Zigzag encode
+  static void encodeVarintInto(uint32_t value, std::vector<uint8_t>& out);                               ///< Varint encode
 
  public:
   ClassDefNV(CMVPerTF, 1)

Detectors/TPC/calibration/macro/drawCMV.C

@@ -11,12 +11,14 @@
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include <string>
+#include <vector>
 #include <string_view>
 #include <fmt/format.h>
 
 #include "TFile.h"
 #include "TParameter.h"
 #include "TTree.h"
+#include "TH1F.h"
 #include "TH2F.h"
 #include "TCanvas.h"
 
@@ -79,34 +81,44 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
                        100, 0, nTimeBins,
                        110, -100.5, 9.5);
   h2d->SetStats(1);
+  TH1F* h1d = new TH1F("hCMV", ";Common Mode Values (ADC);Counts",
+                       1100, -100.5, 9.5);
+  h1d->SetStats(1);
 
   // auto-detect branch format
+  const bool isQuantized = (tree->GetBranch("CMVPerTFQuantized") != nullptr);
   const bool isCombined = (tree->GetBranch("CMVPerTFCombined") != nullptr);
   const bool isSparse = (tree->GetBranch("CMVPerTFSparse") != nullptr);
   const bool isHuffman = (tree->GetBranch("CMVPerTFHuffman") != nullptr);
   const bool isVarint = (tree->GetBranch("CMVPerTFVarint") != nullptr);
   const bool isRaw = (tree->GetBranch("CMVPerTF") != nullptr);
-  if (!isCombined && !isSparse && !isHuffman && !isVarint && !isRaw) {
-    fmt::print("ERROR: no recognised branch found (expected CMVPerTFCombined, CMVPerTFSparse, CMVPerTFHuffman, CMVPerTFVarint, or CMVPerTF)\n");
+  if (!isQuantized && !isCombined && !isSparse && !isHuffman && !isVarint && !isRaw) {
+    fmt::print("ERROR: no recognised branch found (expected CMVPerTFQuantized, CMVPerTFCombined, CMVPerTFSparse, CMVPerTFHuffman, CMVPerTFVarint, or CMVPerTF)\n");
     return arrCanvases;
   }
   const std::string branchFormat =
-    isCombined ? "CMVPerTFCombined (sparse + compressed exact values)" : isSparse  ? "CMVPerTFSparse (sparse)"
-                                                                       : isHuffman ? "CMVPerTFHuffman (delta+zigzag+Huffman)"
-                                                                       : isVarint  ? "CMVPerTFVarint (delta+zigzag+varint)"
-                                                                                   : "CMVPerTF (raw)";
+    isQuantized  ? "CMVPerTFQuantized (sparse + quantized float symbols)"
+    : isCombined ? "CMVPerTFCombined (sparse + compressed exact values)"
+    : isSparse   ? "CMVPerTFSparse (sparse)"
+    : isHuffman  ? "CMVPerTFHuffman (delta+zigzag+Huffman)"
+    : isVarint   ? "CMVPerTFVarint (delta+zigzag+varint)"
+                 : "CMVPerTF (raw)";
   fmt::print("Branch format: {}\n", branchFormat);
 
   // branch setup — only one pointer is active depending on the detected format
+  o2::tpc::CMVPerTFQuantized* tfQuantized = nullptr;
   o2::tpc::CMVPerTFCombined* tfCombined = nullptr;
   o2::tpc::CMVPerTFSparse* tfSparse = nullptr;
   o2::tpc::CMVPerTFHuffman* tfHuffman = nullptr;
   o2::tpc::CMVPerTFVarint* tfVarint = nullptr;
   o2::tpc::CMVPerTF* tfRaw = nullptr;
   // staging object for decompression
-  CMVPerTF* tfDecoded = (isCombined || isSparse || isHuffman || isVarint) ? new CMVPerTF() : nullptr;
+  CMVPerTF* tfDecoded = (isCombined || isSparse || isHuffman || isVarint || isQuantized) ? new CMVPerTF() : nullptr;
+  std::vector<float> tfDecodedFloats;
 
-  if (isCombined) {
+  if (isQuantized) {
+    tree->SetBranchAddress("CMVPerTFQuantized", &tfQuantized);
+  } else if (isCombined) {
     tree->SetBranchAddress("CMVPerTFCombined", &tfCombined);
   } else if (isSparse) {
     tree->SetBranchAddress("CMVPerTFSparse", &tfSparse);
@@ -125,7 +137,11 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
 
     // resolve to a unified pointer regardless of storage format
     const CMVPerTF* tf = nullptr;
-    if (isCombined) {
+    if (isQuantized) {
+      tfQuantized->decompress(tfDecoded);
+      tfQuantized->decompressToFloatBuffer(tfDecodedFloats);
+      tf = tfDecoded;
+    } else if (isCombined) {
       tfCombined->decompress(tfDecoded);
       tf = tfDecoded;
     } else if (isSparse) {
@@ -147,14 +163,17 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
 
     for (int cru = 0; cru < nCRUs; ++cru) {
       for (int tb = 0; tb < nTimeBins; ++tb) {
-        h2d->Fill(tb, tf->getCMVFloat(cru, tb));
-        // fmt::print("cru: {}, tb: {}, cmv: {}\n", cru, tb, tf->getCMVFloat(cru, tb));
+        const float cmvValue = isQuantized ? tfDecodedFloats[cru * nTimeBins + tb] : tf->getCMVFloat(cru, tb);
+        h2d->Fill(tb, cmvValue);
+        h1d->Fill(cmvValue);
+        fmt::print("cru: {}, tb: {}, cmv: {}\n", cru, tb, cmvValue);
       }
     }
   }
 
   delete tfDecoded;
   tree->ResetBranchAddresses();
+  delete tfQuantized;
   delete tfCombined;
   delete tfSparse;
   delete tfHuffman;
@@ -169,6 +188,12 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
 
   arrCanvases->Add(c);
 
+  auto* c1 = new TCanvas("cCMVDistribution", "");
+  c1->SetLogy();
+  h1d->Draw();
+
+  arrCanvases->Add(c1);
+
   if (outDir.size()) {
     utils::saveCanvases(*arrCanvases, outDir, "png,pdf", "CMVCanvases.root");
   }