BaseCluster.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_BASE_BASECLUSTER_H
#define ALICEO2_BASE_BASECLUSTER_H
 
#include <MathUtils/Cartesian.h>
#include "GPUCommonRtypes.h"
#ifndef GPUCA_GPUCODE
#include "DetectorsCommonDataFormats/DetMatrixCache.h"
#include <bitset>
#include <iomanip>
#include <ios>
#include <iosfwd>
#endif
 
namespace o2
{
// Basic cluster class with X,Y,Z position detector ID information + user fields
// The position is ALWAYS stored in tracking frame and is misaligned (in opposite
// to AliRoot). The errors are defined in *ideal* tracking frame
// DetectorID should correspond to continuous (no jumps between detector layers
// planes etc.) internal sensor ID within detector
template <typename T>
class BaseCluster
{
 private:
  math_utils::Point3D<T> mPos; // cartesian position
  T mSigmaY2;                  // error in Y direction (usually rphi)
  T mSigmaZ2;                  // error in Z direction (usually Z)
  T mSigmaYZ;                  // non-diagonal term of error matrix
  std::uint16_t mSensorID = 0; // the sensor id
  std::int8_t mCount = 0;      // user field reserved for counting
  std::uint8_t mBits = 0;      // user field reserved for bit flags
  enum masks_t : std::int32_t { kUserBitsMask = 0xff };
 
 public:
  BaseCluster() = default;
  ~BaseCluster() = default;
 
  // constructor
  BaseCluster(std::uint16_t sensid, const math_utils::Point3D<T>& xyz) : mPos(xyz), mSensorID(sensid) {}
  BaseCluster(std::uint16_t sensid, T x, T y, T z) : mPos(x, y, z), mSensorID(sensid) {}
  BaseCluster(std::uint16_t sensid, const math_utils::Point3D<T>& xyz, T sy2, T sz2, T syz)
    : mPos(xyz), mSigmaY2(sy2), mSigmaZ2(sz2), mSigmaYZ(syz), mSensorID(sensid)
  {
  }
  BaseCluster(std::int16_t sensid, T x, T y, T z, T sy2, T sz2, T syz)
    : mPos(x, y, z), mSigmaY2(sy2), mSigmaZ2(sz2), mSigmaYZ(syz), mSensorID(sensid)
  {
  }
 
  // getting the cartesian coordinates and errors
  T getX() const { return mPos.X(); }
  T getY() const { return mPos.Y(); }
  T getZ() const { return mPos.Z(); }
  T getSigmaY2() const { return mSigmaY2; }
  T getSigmaZ2() const { return mSigmaZ2; }
  T getSigmaYZ() const { return mSigmaYZ; }
  math_utils::Point3D<T> getXYZ() const { return mPos; }
  math_utils::Point3D<T>& getXYZ() { return mPos; }
#ifndef GPUCA_GPUCODE
  // position in local frame, no check for matrices cache validity
  math_utils::Point3D<T> getXYZLoc(const o2::detectors::DetMatrixCache& dm) const { return dm.getMatrixT2L(mSensorID)(mPos); }
  // position in global frame, no check for matrices cache validity
  math_utils::Point3D<T> getXYZGlo(const o2::detectors::DetMatrixCache& dm) const { return dm.getMatrixT2G(mSensorID)(mPos); }
  // position in global frame obtained as simple rotation from tracking one:
  // much faster for barrel detectors than using full 3D matrix.
  // no check for matrices cache validity
  math_utils::Point3D<T> getXYZGloRot(const o2::detectors::DetMatrixCache& dm) const { return dm.getMatrixT2GRot(mSensorID)(mPos); }
#endif
  // get sensor id
  std::int16_t getSensorID() const { return mSensorID; }
  // get count field
  std::int8_t getCount() const { return mCount; }
  // get bit field
  std::uint8_t getBits() const { return mBits; }
  bool isBitSet(int bit) const { return mBits & (0xff & (0x1 << bit)); }
  // cast to Point3D
  operator math_utils::Point3D<T>&() { return mPos; }
  // modifiers
 
  // set sensor id
  void setSensorID(std::int16_t sid) { mSensorID = sid; }
  // set count field
  void setCount(std::int8_t c) { mCount = c; }
  // set bit field
  void setBits(std::uint8_t b) { mBits = b; }
  void setBit(int bit) { mBits |= kUserBitsMask & (0x1 << bit); }
  void resetBit(int bit) { mBits &= ~(kUserBitsMask & (0x1 << bit)); }
  // set position and errors
  void setX(T x) { mPos.SetX(x); }
  void setY(T y) { mPos.SetY(y); }
  void setZ(T z) { mPos.SetZ(z); }
  void setXYZ(T x, T y, T z)
  {
    setX(x);
    setY(y);
    setZ(z);
  }
  void setPos(const math_utils::Point3D<T>& p) { mPos = p; }
  void setSigmaY2(T v) { mSigmaY2 = v; }
  void setSigmaZ2(T v) { mSigmaZ2 = v; }
  void setSigmaYZ(T v) { mSigmaYZ = v; }
  void setErrors(T sy2, T sz2, T syz)
  {
    setSigmaY2(sy2);
    setSigmaZ2(sz2);
    setSigmaYZ(syz);
  }
 
 protected:
  ClassDefNV(BaseCluster, 2);
};
 
#ifndef GPUCA_GPUCODE
template <class T>
std::ostream& operator<<(std::ostream& os, const BaseCluster<T>& c)
{
  // stream itself
  os << "SId" << std::setw(5) << c.getSensorID() << " (" << std::showpos << std::scientific
     << c.getX() << "," << c.getY() << "," << c.getZ() << ")/("
     << c.getSigmaY2() << "," << c.getSigmaYZ() << "," << c.getSigmaZ2()
     << ") cnt:" << std::setw(4) << +c.getCount() << " bits:" << std::bitset<8>(c.getBits());
  return os;
}
#endif
} // namespace o2
#endif