[EMCAL-1046] Swap HG and LG at overflow cut

The reconstruction swap HG and LG at 950 ADC counts
in order to avoid saturation of the HG (i.e. due to
pedestals). The compression instead used the 10 bit
ADC range (1024). In the encoding LG cells in that
energy range are encoded with negative values and
therefore are out-of-range. In addition introduce
a 200 MeV safety margin for the LG in order to not
truncate for cells which are slightly below the
saturation offset due to floating point imprecision.

Author: mfasDa

DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/Cell.h

@@ -60,7 +60,8 @@ class Cell
  public:
   enum class EncoderVersion {
     EncodingV0,
-    EncodingV1
+    EncodingV1,
+    EncodingV2
   };
   /// \brief Default constructor
   Cell() = default;
@@ -202,7 +203,7 @@ class Cell
   /// the limits is provided the energy is
   /// set to the limits (0 in case of negative
   /// energy, 250. in case of energies > 250 GeV)
-  uint16_t getEnergyEncoded(EncoderVersion version = EncoderVersion::EncodingV1) const;
+  uint16_t getEnergyEncoded(EncoderVersion version = EncoderVersion::EncodingV2) const;
 
   /// \brief Get encoded bit representation of cell type (for CTF)
   /// \return Encoded bit representation
@@ -218,10 +219,14 @@ class Cell
   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:
   /// \brief Set cell energy from encoded bit representation (from CTF)

DataFormats/Detectors/EMCAL/src/Cell.cxx

@@ -44,6 +44,21 @@ const float
   ENERGY_RESOLUTION_TRU = ENERGY_TRUNCATION / ENERGY_BITS,
   ENERGY_RESOLUTION_LEDMON = ENERGY_TRUNCATION / ENERGY_BITS;
 }
+
+namespace v2
+{
+const float
+  ENERGY_BITS = static_cast<float>(0x3FFF),
+  SAFETYMARGIN = 0.2,
+  HGLGTRANSITION = o2::emcal::constants::OVERFLOWCUT * o2::emcal::constants::EMCAL_ADCENERGY,
+  OFFSET_LG = HGLGTRANSITION - SAFETYMARGIN,
+  ENERGY_TRUNCATION = 250.,
+  ENERGY_RESOLUTION_LG = (ENERGY_TRUNCATION - OFFSET_LG) / ENERGY_BITS,
+  ENERGY_RESOLUTION_HG = HGLGTRANSITION / ENERGY_BITS,
+  ENERGY_RESOLUTION_TRU = ENERGY_TRUNCATION / ENERGY_BITS,
+  ENERGY_RESOLUTION_LEDMON = ENERGY_TRUNCATION / ENERGY_BITS;
+
+}
 } // namespace EnergyEncoding
 
 namespace DecodingV0
@@ -87,6 +102,10 @@ uint16_t Cell::getEnergyEncoded(EncoderVersion version) const
     case EncoderVersion::EncodingV1:
       energyBits = encodeEnergyV1(mEnergy, mChannelType);
       break;
+
+    case EncoderVersion::EncodingV2:
+      energyBits = encodeEnergyV2(mEnergy, mChannelType);
+      break;
   }
   return energyBits;
 }
@@ -105,6 +124,9 @@ void Cell::setEnergyEncoded(uint16_t energyBits, uint16_t channelTypeBits, Encod
     case EncoderVersion::EncodingV1:
       mEnergy = decodeEnergyV1(energyBits, static_cast<ChannelType_t>(channelTypeBits));
       break;
+    case EncoderVersion::EncodingV2:
+      mEnergy = decodeEnergyV2(energyBits, static_cast<ChannelType_t>(channelTypeBits));
+      break;
   }
 }
 
@@ -214,12 +236,55 @@ uint16_t Cell::encodeEnergyV1(float energy, ChannelType_t celltype)
   return static_cast<uint16_t>(std::round((truncatedEnergy - energyOffset) / resolutionApplied));
 };
 
+uint16_t Cell::encodeEnergyV2(float energy, ChannelType_t celltype)
+{
+  double truncatedEnergy = energy;
+  if (truncatedEnergy < 0.) {
+    truncatedEnergy = 0.;
+  } else if (truncatedEnergy > EnergyEncoding::v2::ENERGY_TRUNCATION) {
+    truncatedEnergy = EnergyEncoding::v2::ENERGY_TRUNCATION;
+  }
+  float resolutionApplied = 0., energyOffset = 0.;
+  switch (celltype) {
+    case ChannelType_t::HIGH_GAIN: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_HG;
+      break;
+    }
+    case ChannelType_t::LOW_GAIN: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_LG;
+      energyOffset = EnergyEncoding::v2::OFFSET_LG;
+      break;
+    }
+    case ChannelType_t::TRU: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_TRU;
+      break;
+    }
+    case ChannelType_t::LEDMON: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_LEDMON;
+      break;
+    }
+  }
+  return static_cast<uint16_t>(std::round((truncatedEnergy - energyOffset) / resolutionApplied));
+};
+
 uint16_t Cell::V0toV1(uint16_t energyBits, ChannelType_t celltype)
 {
   auto decodedEnergy = decodeEnergyV0(energyBits);
   return encodeEnergyV1(decodedEnergy, celltype);
 }
 
+uint16_t Cell::V0toV2(uint16_t energyBits, ChannelType_t celltype)
+{
+  auto decodedEnergy = decodeEnergyV0(energyBits);
+  return encodeEnergyV2(decodedEnergy, celltype);
+}
+
+uint16_t Cell::V1toV2(uint16_t energyBits, ChannelType_t celltype)
+{
+  auto decodedEnergy = decodeEnergyV1(energyBits, celltype);
+  return encodeEnergyV2(decodedEnergy, celltype);
+}
+
 float Cell::decodeTime(uint16_t timestampBits)
 {
   return (static_cast<float>(timestampBits) * TimeEncoding::TIME_RESOLUTION) - TimeEncoding::TIME_SHIFT;
@@ -256,6 +321,32 @@ float Cell::decodeEnergyV1(uint16_t energyBits, ChannelType_t celltype)
   return (static_cast<float>(energyBits) * resolutionApplied) + energyOffset;
 }
 
+float Cell::decodeEnergyV2(uint16_t energyBits, ChannelType_t celltype)
+{
+  float resolutionApplied = 0.,
+        energyOffset = 0.;
+  switch (celltype) {
+    case ChannelType_t::HIGH_GAIN: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_HG;
+      break;
+    }
+    case ChannelType_t::LOW_GAIN: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_LG;
+      energyOffset = EnergyEncoding::v2::OFFSET_LG;
+      break;
+    }
+    case ChannelType_t::TRU: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_TRU;
+      break;
+    }
+    case ChannelType_t::LEDMON: {
+      resolutionApplied = EnergyEncoding::v2::ENERGY_RESOLUTION_LEDMON;
+      break;
+    }
+  }
+  return (static_cast<float>(energyBits) * resolutionApplied) + energyOffset;
+}
+
 void Cell::PrintStream(std::ostream& stream) const
 {
   stream << "EMCAL Cell: Type " << getType() << ", Energy " << getEnergy() << ", Time " << getTimeStamp() << ", Tower " << getTower();

Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h

@@ -169,6 +169,8 @@ o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VTRG& trigVec, VCELL& c
   Cell::EncoderVersion encodingversion = o2::emcal::Cell::EncoderVersion::EncodingV0;
   if (header.majorVersion == 1 && header.minorVersion == 1) {
     encodingversion = o2::emcal::Cell::EncoderVersion::EncodingV1;
+  } else if (header.majorVersion == 1 && header.minorVersion == 2) {
+    encodingversion = o2::emcal::Cell::EncoderVersion::EncodingV2;
   }
 
   uint32_t firstEntry = 0, cellCount = 0;

Detectors/EMCAL/reconstruction/src/CTFCoder.cxx

@@ -66,6 +66,6 @@ void CTFCoder::assignDictVersion(o2::ctf::CTFDictHeader& h) const
     h = mExtHeader;
   } else {
     h.majorVersion = 1;
-    h.minorVersion = 1;
+    h.minorVersion = 2;
   }
 }