Cell.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_EMCAL_CELL_H_
#define ALICEO2_EMCAL_CELL_H_
 
#include "DataFormatsEMCAL/Constants.h"
 
#include <cfloat>
#include <climits>
 
namespace o2::emcal
{
 
class Cell
{
 public:
  enum class EncoderVersion {
    EncodingV0,
    EncodingV1,
    EncodingV2
  };
  Cell() = default;
 
  Cell(short tower, float energy, float timestamp, ChannelType_t ctype = ChannelType_t::LOW_GAIN);
 
  Cell(uint16_t towerBits, uint16_t energyBits, uint16_t timestampBits, uint16_t channelBits, EncoderVersion version = EncoderVersion::EncodingV1);
 
  ~Cell() = default; // override
 
  void setTower(short tower) { mTowerID = tower; }
 
  [[nodiscard]] short getTower() const { return mTowerID; }
 
  void setTimeStamp(float timestamp) { mTimestamp = timestamp; }
 
  [[nodiscard]] float getTimeStamp() const { return mTimestamp; }
 
  void setEnergy(float energy) { mEnergy = energy; }
 
  [[nodiscard]] float getEnergy() const { return mEnergy; }
 
  void setAmplitude(float amplitude) { setEnergy(amplitude); }
 
  [[nodiscard]] float getAmplitude() const { return getEnergy(); }
 
  void setType(ChannelType_t ctype) { mChannelType = ctype; }
 
  [[nodiscard]] ChannelType_t getType() const { return mChannelType; }
 
  [[nodiscard]] bool isChannelType(ChannelType_t ctype) const { return mChannelType == ctype; }
 
  void setLowGain() { setType(ChannelType_t::LOW_GAIN); }
 
  [[nodiscard]] Bool_t getLowGain() const { return isChannelType(ChannelType_t::LOW_GAIN); }
 
  void setHighGain() { setType(ChannelType_t::HIGH_GAIN); }
 
  [[nodiscard]] Bool_t getHighGain() const { return isChannelType(ChannelType_t::HIGH_GAIN); };
 
  void setLEDMon() { setType(ChannelType_t::LEDMON); }
 
  [[nodiscard]] Bool_t getLEDMon() const { return isChannelType(ChannelType_t::LEDMON); }
 
  void setTRU() { setType(ChannelType_t::TRU); }
 
  [[nodiscard]] Bool_t getTRU() const { return isChannelType(ChannelType_t::TRU); }
 
  void truncate(EncoderVersion version = EncoderVersion::EncodingV1);
 
  void PrintStream(std::ostream& stream) const;
 
  void initialiseFromEncoded(uint16_t towerIDBits, uint16_t timestampBits, uint16_t energyBits, uint16_t celltypeBits, EncoderVersion version = EncoderVersion::EncodingV1)
  {
    setEnergyEncoded(energyBits, static_cast<ChannelType_t>(celltypeBits), version);
    setTimestampEncoded(timestampBits);
    setTowerIDEncoded(towerIDBits);
    setChannelTypeEncoded(celltypeBits);
  }
 
  [[nodiscard]] uint16_t getTowerIDEncoded() const;
 
  [[nodiscard]] uint16_t getTimeStampEncoded() const;
 
  [[nodiscard]] uint16_t getEnergyEncoded(EncoderVersion version = EncoderVersion::EncodingV2) const;
 
  [[nodiscard]] uint16_t getCellTypeEncoded() const;
 
  void initializeFromPackedBitfieldV0(const char* bitfield);
 
  static float getEnergyFromPackedBitfieldV0(const char* bitfield);
  static float getTimeFromPackedBitfieldV0(const char* bitfield);
  static ChannelType_t getCellTypeFromPackedBitfieldV0(const char* bitfield);
  static short getTowerFromPackedBitfieldV0(const char* bitfield);
 
  static uint16_t encodeTime(float timestamp);
  static uint16_t encodeEnergyV0(float energy);
  static uint16_t encodeEnergyV1(float energy, ChannelType_t celltype);
  static uint16_t encodeEnergyV2(float energy, ChannelType_t celltype);
  static uint16_t V0toV1(uint16_t energybits, ChannelType_t celltype);
  static uint16_t V0toV2(uint16_t energybits, ChannelType_t celltype);
  static uint16_t V1toV2(uint16_t energybits, ChannelType_t celltype);
  static float decodeTime(uint16_t timestampBits);
  static float decodeEnergyV0(uint16_t energybits);
  static float decodeEnergyV1(uint16_t energybits, ChannelType_t celltype);
  static float decodeEnergyV2(uint16_t energybits, ChannelType_t celltype);
 
 private:
  void setEnergyEncoded(uint16_t energyBits, uint16_t channelTypeBits, EncoderVersion version = EncoderVersion::EncodingV1);
 
  void setTimestampEncoded(uint16_t timestampBits);
 
  void setTowerIDEncoded(uint16_t towerIDBits);
 
  void setChannelTypeEncoded(uint16_t channelTypeBits);
 
  float mEnergy = FLT_MIN;                               
  float mTimestamp = FLT_MIN;                            
  short mTowerID = SHRT_MAX;                             
  ChannelType_t mChannelType = ChannelType_t::HIGH_GAIN; 
 
  ClassDefNV(Cell, 3);
};
 
std::ostream& operator<<(std::ostream& stream, const Cell& cell);
} // namespace o2::emcal
 
#endif