CbmStsDigi.h

Go to the documentation of this file.

/* Copyright (C) 2006-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese, Denis Bertini [committer], Florian Uhlig */
 
#ifndef CBMSTSDIGI_H
#define CBMSTSDIGI_H 1
 
#include "CbmDefs.h"  // for ECbmModuleId::kSts
#include "CbmStsAddress.h"
 
#include <xpu/defines.h>  // for XPU_D
 
#if !defined(NO_ROOT) && !XPU_IS_HIP_CUDA
#include <Rtypes.h>  // for ClassDef
#endif
 
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
 
#include <cassert>
#include <string>  // for string
 
class CbmStsDigi {
 
public:  // constants
  static constexpr int kNumAdcBits              = 5;
  static constexpr uint32_t kAdcMask            = (1u << kNumAdcBits) - 1u;
  static constexpr int kNumLowerAddrBits        = 16;
  static constexpr int kNumTimestampBits        = 31;
  static constexpr uint32_t kTimestampMask      = (1u << kNumTimestampBits) - 1u;
  static constexpr uint32_t kMaxTimestamp       = kTimestampMask;
  static constexpr uint32_t kTimeAddressBitMask = ~kTimestampMask;
 
public:
  CbmStsDigi() = default;
 
  XPU_D CbmStsDigi(int32_t address, int32_t channel, uint32_t time, uint16_t charge)
  {
    time = ClampTime(time);
    PackAddressAndTime(address, time);
    PackChannelAndCharge(channel, charge);
  }
 
  ~CbmStsDigi() = default;
 
  XPU_D int32_t GetAddress() const { return UnpackAddress(); }
 
 
  XPU_D int32_t GetAddressPacked() const
  {
    int32_t highestBitAddr = fTime >> kNumTimestampBits;
    int32_t packedAddress  = (highestBitAddr << kNumLowerAddrBits) | int32_t(fAddress);
    return packedAddress;
  }
 
  static const char* GetBranchName() { return "StsDigi"; }
 
 
  XPU_D uint16_t GetChannel() const { return UnpackChannel(); }
 
 
  static const char* GetClassName() { return "CbmStsDigi"; }
 
#if XPU_IS_CPU
  double GetCharge() const { return static_cast<double>(UnpackCharge()); }
#endif
 
  XPU_D uint16_t GetChargeU16() const { return UnpackCharge(); }
 
 
  static ECbmModuleId GetSystem() { return ECbmModuleId::kSts; }
 
#if XPU_IS_CPU
  double GetTime() const { return static_cast<double>(UnpackTime()); }
#endif
 
  XPU_D uint32_t GetTimeU32() const { return UnpackTime(); }
 
 
  template<class Archive>
  void serialize(Archive& ar, const unsigned int /*version*/)
  {
    ar& fTime;
    ar& fChannelAndCharge;
    ar& fAddress;
  }
 
 
  XPU_D void SetTime(uint32_t dNewTime)
  {
    dNewTime = ClampTime(dNewTime);
    PackTime(dNewTime);
  }
 
  XPU_D void SetChannel(uint16_t channel) { PackChannelAndCharge(channel, UnpackCharge()); }
 
  XPU_D void SetCharge(uint16_t charge) { PackChannelAndCharge(UnpackChannel(), charge); }
 
  XPU_D void SetAddress(int32_t address) { PackAddressAndTime(address, UnpackTime()); }
 
 
  XPU_D void SetChannelAndCharge(uint16_t channel, uint16_t charge) { PackChannelAndCharge(channel, charge); }
 
  XPU_D void SetAddressAndTime(int32_t address, uint32_t time)
  {
    time = ClampTime(time);
    PackAddressAndTime(address, time);
  }
 
 
  std::string ToString() const;
 
 
private:
  friend class boost::serialization::access;
 
 
  uint32_t fTime;              
  uint16_t fChannelAndCharge;  
  uint16_t fAddress;           
 
 
  XPU_D void PackTime(uint32_t newTime) { fTime = (fTime & kTimeAddressBitMask) | (newTime & kTimestampMask); }
  XPU_D uint32_t UnpackTime() const { return fTime & kTimestampMask; }
 
 
  XPU_D void PackChannelAndCharge(uint16_t channel, uint16_t charge)
  {
    fChannelAndCharge = (channel << kNumAdcBits) | charge;
  }
  XPU_D uint16_t UnpackChannel() const { return fChannelAndCharge >> kNumAdcBits; }
  XPU_D uint16_t UnpackCharge() const { return fChannelAndCharge & kAdcMask; }
 
  XPU_D void PackAddressAndTime(int32_t newAddress, uint32_t newTime)
  {
    int32_t packedAddr = CbmStsAddress::PackDigiAddress(newAddress);
 
    uint32_t highestBitAddr = packedAddr >> kNumLowerAddrBits;
    uint32_t lowerAddr      = packedAddr & ((1 << kNumLowerAddrBits) - 1);
 
    fAddress = lowerAddr;
    fTime    = (highestBitAddr << kNumTimestampBits) | (kTimestampMask & newTime);
  }
 
  XPU_D int32_t UnpackAddress() const
  {
    int32_t packedAddress = GetAddressPacked();
    return CbmStsAddress::UnpackDigiAddress(packedAddress);
  }
 
  XPU_D uint32_t ClampTime(uint32_t time) const
  {
    if (time > kMaxTimestamp) time = kMaxTimestamp;
    return time;
  }
 
#if !defined(NO_ROOT) && !XPU_IS_HIP_CUDA
  ClassDefNV(CbmStsDigi, 8);
#endif
};
 
#endif