IDC.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_IDC_H
#define ALICEO2_DATAFORMATSTPC_IDC_H
 
#include <bitset>
 
namespace o2::tpc::idc
{
static constexpr uint32_t Links = 10;                                           
static constexpr uint32_t Channels = 80;                                        
static constexpr uint32_t DataWordSizeBits = 256;                               
static constexpr uint32_t DataWordSizeBytes = DataWordSizeBits / 8;             
static constexpr uint32_t IDCvalueBits = 25;                                    
static constexpr uint32_t IDCvalueBitsMask = (uint32_t(1) << IDCvalueBits) - 1; 
static constexpr uint32_t SignificantBits = 2;                                  
static constexpr float FloatConversion = 1.f / float(1 << SignificantBits);     
 
struct Header {
  static constexpr uint32_t MagicWord = 0xDC;
  union {
    uint64_t word0 = 0;              
    struct {                         
      uint32_t version : 8;          
      uint32_t packetID : 8;         
      uint32_t errorCode : 8;        
      uint32_t magicWord : 8;        
      uint32_t heartbeatOrbit : 32;  
    };                               
  };                                 
  union {                            
    uint64_t word1 = 0;              
    struct {                         
      uint32_t heartbeatBC : 16;     
      uint32_t integrationTime : 16; 
      uint32_t linkMask : 16;        
      uint32_t unused1 : 16;         
    };                               
  };                                 
  union {                            
    uint64_t word2 = 0;              
    struct {                         
      uint64_t unused2 : 64;         
    };                               
  };                                 
  union {                            
    uint64_t word3 = 0;              
    struct {                         
      uint64_t unused3 : 64;         
    };                               
  };                                 
};
 
struct Data {
  uint8_t dataWords[DataWordSizeBytes] = {0}; 
 
  uint32_t getLinkValue(const uint32_t link) const
  {
    const auto valPtr = dataWords;
    const uint32_t offset = link * IDCvalueBits;
    const uint32_t selectedWord = offset / 8;
    const uint32_t requiredShift = offset % 8;
    const uint32_t value = (*(uint32_t*)(dataWords + selectedWord)) >> requiredShift;
    return value & IDCvalueBitsMask;
  }
 
  void setLinkValue(const uint32_t link, const uint32_t value)
  {
    const uint32_t offset = link * IDCvalueBits;
    const uint32_t selectedWord = offset / 8;
    const uint32_t requiredShift = offset % 8;
    auto dataWrite = (uint64_t*)&dataWords[selectedWord];
    *dataWrite = (value & IDCvalueBitsMask) << requiredShift;
  }
};
 
struct Container {
  Header header;              
  Data channelData[Channels]; 
 
  bool hasLink(const uint32_t link)
  {
    return (header.linkMask & (1 << link));
  }
 
  uint32_t getChannelValue(const uint32_t link, const uint32_t channel) const
  {
    return channelData[channel].getLinkValue(link);
  }
 
  void setChannelValue(const uint32_t link, const uint32_t channel, uint32_t value)
  {
    channelData[channel].setLinkValue(link, value);
  }
 
  float getChannelValueFloat(const uint32_t link, const uint32_t channel) const
  {
    return float(channelData[channel].getLinkValue(link)) * FloatConversion;
  }
 
  void setChannelValueFloat(const uint32_t link, const uint32_t channel, float value)
  {
    channelData[channel].setLinkValue(link, uint32_t((value + 0.5f * FloatConversion) / FloatConversion));
  }
};
} // namespace o2::tpc::idc
#endif