CMVContainer.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_TPC_CMVCONTAINER_H_
#define ALICEO2_TPC_CMVCONTAINER_H_
 
#include <string>
#include <memory>
#include <vector>
#include <cstdint>
 
#include "TTree.h"
#include "TPCBase/CRU.h"
#include "DataFormatsTPC/CMV.h"
 
namespace o2::tpc
{
 
struct CMVPerTF;           // forward declaration
struct CMVPerTFCompressed; // forward declaration
 
struct CMVEncoding {
  static constexpr uint8_t kNone = 0x00;    
  static constexpr uint8_t kSparse = 0x01;  
  static constexpr uint8_t kDelta = 0x02;   
  static constexpr uint8_t kZigzag = 0x04;  
  static constexpr uint8_t kVarint = 0x08;  
  static constexpr uint8_t kHuffman = 0x10; 
};
 
struct CMVPerTFCompressed {
  uint32_t firstOrbit{0};    
  uint32_t firstOrbitDPL{0}; 
  uint8_t mFlags{0};         
 
  std::vector<uint8_t> mData; 
 
  void decompress(CMVPerTF* cmv) const;
 
  std::unique_ptr<TTree> toTTree() const;
 
 private:
  static std::vector<std::pair<int, uint32_t>> decodeSparsePositions(const uint8_t*& ptr, const uint8_t* end);
 
  static std::vector<uint32_t> decodeValueStream(const uint8_t*& ptr, const uint8_t* end, uint32_t N, uint8_t flags);
 
  static void decodeSparseValues(const std::vector<uint32_t>& symbols,
                                 const std::vector<std::pair<int, uint32_t>>& positions,
                                 uint8_t flags, CMVPerTF* cmv);
 
  static void decodeDenseValues(const std::vector<uint32_t>& symbols, uint8_t flags, CMVPerTF* cmv);
 
 public:
  ClassDefNV(CMVPerTFCompressed, 2)
};
 
struct CMVPerTF {
  uint32_t firstOrbit{0};    
  uint32_t firstOrbitDPL{0}; 
 
  // Raw 16-bit CMV values, flat array indexed as [cru * NTimeBinsPerTF + timeBin]
  uint16_t mDataPerTF[CRU::MaxCRU * cmv::NTimeBinsPerTF]{};
 
  uint16_t getCMV(const int cru, const int timeBin) const;
 
  float getCMVFloat(const int cru, const int timeBin) const;
 
  void zeroSmallValues(float threshold = 1.0f);
 
  void roundToIntegers(uint16_t threshold);
 
  void trimGaussianPrecision(float mean, float sigma);
 
  CMVPerTFCompressed compress(uint8_t flags) const;
 
  std::unique_ptr<TTree> toTTree() const;
 
  static void writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree);
 
 private:
  static int32_t cmvToSigned(uint16_t raw);                                                              
  static uint16_t quantizeBelowThreshold(uint16_t raw, float quantizationMean, float quantizationSigma); 
  static uint32_t zigzagEncode(int32_t value);                                                           
  static void encodeVarintInto(uint32_t value, std::vector<uint8_t>& out);                               
 
 public:
  ClassDefNV(CMVPerTF, 2)
};
 
} // namespace o2::tpc
 
#endif // ALICEO2_TPC_CMVCONTAINER_H_