CMV.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
 
#ifndef ALICEO2_DATAFORMATSTPC_CMV_H
#define ALICEO2_DATAFORMATSTPC_CMV_H
 
#include <cstdint>
#include <cmath>
 
namespace o2::tpc::cmv
{
 
static constexpr uint32_t NTimeBinsPerPacket = 3564;                                 
static constexpr uint32_t NPacketsPerTFPerCRU = 4;                                   
static constexpr uint32_t NTimeBinsPerTF = NTimeBinsPerPacket * NPacketsPerTFPerCRU; 
 
static constexpr uint32_t DataSizeBytes = NTimeBinsPerPacket * sizeof(uint16_t); 
static constexpr uint32_t DataPaddingBytes = (32 - (DataSizeBytes % 32)) % 32;   
 
struct Header {
  static constexpr uint8_t MagicWord = 0xDC;
  union {
    uint64_t word0 = 0; 
    struct {
      uint8_t version : 8;          
      uint8_t packetID : 8;         
      uint8_t errorCode : 8;        
      uint8_t magicWord : 8;        
      uint32_t heartbeatOrbit : 32; 
    };
  };
  union {
    uint64_t word1 = 0; 
    struct {
      uint16_t heartbeatBC : 16; 
      uint16_t unused1 : 16;     
      uint32_t unused2 : 32;     
    };
  };
  union {
    uint64_t word3 = 0; 
    struct {
      uint64_t unused3 : 64; 
    };
  };
  union {
    uint64_t word4 = 0; 
    struct {
      uint64_t unused4 : 64; 
    };
  };
};
 
struct Data {
  uint16_t cmv{0}; 
 
  uint16_t getCMV() const { return cmv; }      
  void setCMV(uint16_t value) { cmv = value; } 
 
  // 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)
  {
    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;
  }
};
 
struct Container {
  Header header;                       
  Data data[NTimeBinsPerPacket];       
  uint8_t padding[DataPaddingBytes]{}; 
 
  // Header and data accessors
  const Header& getHeader() const { return header; }
  Header& getHeader() { return header; }
 
  const Data* getData() const { return data; }
  Data* getData() { return data; }
 
  // 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); }
 
  float getCMVFloat(uint32_t timeBin) const { return data[timeBin].getCMVFloat(); }
  void setCMVFloat(uint32_t timeBin, float value) { data[timeBin].setCMVFloat(value); }
};
 
} // namespace o2::tpc::cmv
 
#endif