Changed the decoding and encoding of CMVs, removed grouping per side

Author: tubagundem

DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h

@@ -15,21 +15,21 @@
 
 /// The data is sent by the CRU as 256+16 bit words. The CMV data layout is as follows:
 /// - 256-bit Header: [version:8][packetID:8][errorCode:8][magicWord:8][heartbeatOrbit:32][heartbeatBC:16][padding:176]
-/// - 16-bit CMV value: [CMV:16]
+/// - 16-bit CMV value: [sign:1][I8F7:15] where bit 15 is the sign (1=positive, 0=negative) and the lower 15 bits are a fixed point I8F7 value (8 integer bits, 7 fractional bits)
+///   Float conversion: sign ? (value & 0x7FFF) / 128.0 : -(value & 0x7FFF) / 128.0
 
 #ifndef ALICEO2_DATAFORMATSTPC_CMV_H
 #define ALICEO2_DATAFORMATSTPC_CMV_H
 
 #include <cstdint>
+#include <cmath>
 
 namespace o2::tpc::cmv
 {
 
 static constexpr uint32_t NTimeBinsPerPacket = 3564;                                 ///< number of time bins (covering 8 heartbeats)
 static constexpr uint32_t NPacketsPerTFPerCRU = 4;                                   ///< 4 packets per timeframe
 static constexpr uint32_t NTimeBinsPerTF = NTimeBinsPerPacket * NPacketsPerTFPerCRU; ///< maximum number of timebins per timeframe (14256)
-static constexpr uint32_t SignificantBits = 2;                                       ///< number of bits used for floating point precision
-static constexpr float FloatConversion = 1.f / float(1 << SignificantBits);          ///< conversion factor from integer representation to float
 
 /// Header definition of the CMVs
 struct Header {
@@ -83,18 +83,25 @@ struct Header {
 
 /// CMV single data container
 struct Data {
-  uint16_t CMV{0}; ///< 16bit ADC value
+  uint16_t CMV{0}; ///< 16-bit signed fixed point value: bit 15 = sign (1=positive, 0=negative), bits 14-0 = I8F7 magnitude
 
-  // Raw integer accessors
-  uint16_t getCMV() const { return CMV; }
-  void setCMV(uint16_t value) { CMV = value; }
+  uint16_t getCMV() const { return CMV; }      ///< raw 16-bit integer representation
+  void setCMV(uint16_t value) { CMV = value; } ///< set raw 16-bit integer representation
 
-  // Float helpers using SignificantBits for fixed-point conversion
-  float getCMVFloat() const { return static_cast<float>(CMV) * FloatConversion; }
+  // Decode to float: sign-magnitude with 7 fractional bits, range ±255.992
+  float getCMVFloat() const
+  {
+    const bool positive = (CMV >> 15) & 1;          // bit 15: sign (1=positive, 0=negative)
+    const float magnitude = (CMV & 0x7FFF) / 128.f; // lower 15 bits, shift right by 7 (divide by 2^7)
+    return positive ? magnitude : -magnitude;
+  }
+
+  // Encode from float: clamps magnitude to 15 bits, range ±255.992
   void setCMVFloat(float value)
   {
-    // round to nearest representable fixed-point value
-    setCMV(uint32_t((value + 0.5f * FloatConversion) / FloatConversion));
+    const bool positive = (value >= 0.f);
+    const uint16_t magnitude = static_cast<uint16_t>(std::abs(value) * 128.f + 0.5f) & 0x7FFF;
+    CMV = (positive ? 0x8000 : 0x0000) | magnitude;
   }
 };
 
@@ -110,7 +117,7 @@ struct Container {
   const Data* getData() const { return data; }
   Data* getData() { return data; }
 
-  // Per-time-bin CMV accessors
+  // Per timebin CMV accessors
   uint16_t getCMV(uint32_t timeBin) const { return data[timeBin].getCMV(); }
   void setCMV(uint32_t timeBin, uint16_t value) { data[timeBin].setCMV(value); }
 

Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h

@@ -25,7 +25,6 @@
 #include "Headers/DataHeader.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "TPCWorkflow/TPCFLPCMVSpec.h"
-#include "TPCBase/CRU.h"
 #include "MemoryResources/MemoryResources.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "DetectorsBase/GRPGeomHelper.h"
@@ -38,27 +37,6 @@ using namespace o2::tpc;
 namespace o2::tpc
 {
 
-inline std::vector<Side> getCMVSides(const std::vector<uint32_t>& crus)
-{
-  bool hasA = false, hasC = false;
-  for (const auto cru : crus) {
-    const Side side = CRU(cru).side();
-    if (side == Side::A) {
-      hasA = true;
-    } else {
-      hasC = true;
-    }
-  }
-  std::vector<Side> sides;
-  if (hasA) {
-    sides.emplace_back(Side::A);
-  }
-  if (hasC) {
-    sides.emplace_back(Side::C);
-  }
-  return sides;
-}
-
 class TPCDistributeCMVSpec : public o2::framework::Task
 {
  public:
@@ -84,11 +62,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       }
     }
 
-    const auto sides = getCMVSides(mCRUs);
-    for (auto side : sides) {
-      const std::string name = (side == Side::A) ? "cmvsgroupa" : "cmvsgroupc";
-      mFilter.emplace_back(InputSpec{name.data(), ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(side)}, Lifetime::Sporadic});
-    }
+    mFilter.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
   };
 
   void init(o2::framework::InitContext& ic) final
@@ -364,11 +338,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
 DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const unsigned int timeframes, const unsigned int outlanes, const int firstTF, const bool sendPrecisetimeStamp = false, const int nTFsBuffer = 1)
 {
   std::vector<InputSpec> inputSpecs;
-  const auto sides = getCMVSides(crus);
-  for (auto side : sides) {
-    const std::string name = (side == Side::A) ? "cmvsgroupa" : "cmvsgroupc";
-    inputSpecs.emplace_back(InputSpec{name.data(), ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(side)}, Lifetime::Sporadic});
-  }
+  inputSpecs.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
 
   std::vector<OutputSpec> outputSpecs;
   outputSpecs.reserve(outlanes);

Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h

@@ -90,9 +90,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
     ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
   }
 
-  static constexpr header::DataDescription getDataDescriptionCMVGroup(const Side side) { return (side == Side::A) ? getDataDescriptionCMVGroupA() : getDataDescriptionCMVGroupC(); }
-  static constexpr header::DataDescription getDataDescriptionCMVGroupA() { return header::DataDescription{"CMVGROUPA"}; }
-  static constexpr header::DataDescription getDataDescriptionCMVGroupC() { return header::DataDescription{"CMVGROUPC"}; }
+  static constexpr header::DataDescription getDataDescriptionCMVGroup() { return header::DataDescription{"CMVGROUP"}; }
 
  private:
   const int mLane{};                                                ///< lane number of processor
@@ -106,7 +104,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
   void sendOutput(DataAllocator& output, const uint32_t cru)
   {
     const header::DataHeader::SubSpecificationType subSpec{cru << 7};
-    output.adoptContainer(Output{gDataOriginTPC, getDataDescriptionCMVGroup(CRU(cru).side()), subSpec}, std::move(mCMVs[cru]));
+    output.adoptContainer(Output{gDataOriginTPC, getDataDescriptionCMVGroup(), subSpec}, std::move(mCMVs[cru]));
   }
 };
 
@@ -120,8 +118,7 @@ DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::vector<uint32_t>&
   for (const auto& cru : crus) {
     const header::DataHeader::SubSpecificationType subSpec{cru << 7};
     inputSpecs.emplace_back(InputSpec{"cmvs", gDataOriginTPC, "CMVVECTOR", subSpec, Lifetime::Timeframe});
-    const Side side = CRU(cru).side();
-    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(side), subSpec}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(), subSpec}, Lifetime::Sporadic);
   }
 
   const auto id = fmt::format("tpc-flp-cmv-{:02}", ilane);