AnalysisCluster.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_ANALYSISCLUSTER_H_
#define ALICEO2_EMCAL_ANALYSISCLUSTER_H_
 
#include "MathUtils/Cartesian.h" // IWYU pragma: keep
 
#include <Rtypes.h>
#include <TLorentzVector.h>
 
#include <fairlogger/Logger.h>
#include <gsl/span>
 
#include <array>
 
namespace o2::emcal
{
 
 
class AnalysisCluster
{
 
 public:
  class CellOutOfRangeException final : public std::exception
  {
   public:
    CellOutOfRangeException(Int_t cellIndex) : mCellIndex(cellIndex),
                                               mMessage("Cell index " + std::to_string(mCellIndex) + " out of range.")
    {
    }
 
    ~CellOutOfRangeException() noexcept final = default;
 
    [[nodiscard]] Int_t getCellIndex() const noexcept { return mCellIndex; }
 
    [[nodiscard]] const char* what() const noexcept final { return mMessage.data(); }
 
   private:
    Int_t mCellIndex;     
    std::string mMessage; 
  };
 
  AnalysisCluster() = default;
  ~AnalysisCluster() = default;
  AnalysisCluster(const AnalysisCluster& clus) = default;
  AnalysisCluster& operator=(const AnalysisCluster& source) = default;
  void clear();
 
  // Common EMCAL/PHOS/FMD/PMD
 
  void setID(int id) { mID = id; }
  [[nodiscard]] int getID() const { return mID; }
 
  void setE(float ene) { mEnergy = ene; }
  [[nodiscard]] float E() const { return mEnergy; }
 
  void setChi2(float chi2) { mChi2 = chi2; }
  [[nodiscard]] float Chi2() const { return mChi2; }
 
  void setGlobalPosition(const math_utils::Point3D<float>& x);
  [[nodiscard]] math_utils::Point3D<float> getGlobalPosition() const
  {
    return mGlobalPos;
  }
 
  void setLocalPosition(const math_utils::Point3D<float>& x);
  [[nodiscard]] math_utils::Point3D<float> getLocalPosition() const
  {
    return mLocalPos;
  }
 
  void setDispersion(float disp) { mDispersion = disp; }
  [[nodiscard]] float getDispersion() const { return mDispersion; }
 
  void setM20(float m20) { mM20 = m20; }
  [[nodiscard]] float getM20() const { return mM20; }
 
  void setM02(float m02) { mM02 = m02; }
  [[nodiscard]] float getM02() const { return mM02; }
 
  void setNExMax(unsigned char nExMax) { mNExMax = nExMax; }
  [[nodiscard]] unsigned char getNExMax() const { return mNExMax; }
 
  void setEmcCpvDistance(float dEmcCpv) { mEmcCpvDistance = dEmcCpv; }
  [[nodiscard]] float getEmcCpvDistance() const { return mEmcCpvDistance; }
  void setTrackDistance(float dx, float dz)
  {
    mTrackDx = dx;
    mTrackDz = dz;
  }
  [[nodiscard]] float getTrackDx() const { return mTrackDx; }
  [[nodiscard]] float getTrackDz() const { return mTrackDz; }
 
  void setDistanceToBadChannel(float dist) { mDistToBadChannel = dist; }
  [[nodiscard]] float getDistanceToBadChannel() const { return mDistToBadChannel; }
 
  void setNCells(int n) { mNCells = n; }
  [[nodiscard]] int getNCells() const { return mNCells; }
 
  void setCellsIndices(const std::vector<unsigned short>& array)
  {
    mCellsIndices = array;
  }
 
  [[nodiscard]] const std::vector<unsigned short>& getCellsIndices() const { return mCellsIndices; }
 
  void setCellsAmplitudeFraction(const std::vector<float>& array)
  {
    mCellsAmpFraction = array;
  }
  [[nodiscard]] const std::vector<float>& getCellsAmplitudeFraction() const { return mCellsAmpFraction; }
 
  [[nodiscard]] int getCellIndex(int i) const
  {
    if (i >= 0 && i < mNCells) {
      return mCellsIndices[i];
    }
    throw CellOutOfRangeException(i);
  }
 
  [[nodiscard]] float getCellAmplitudeFraction(int i) const
  {
    if (i >= 0 && i < mNCells) {
      return mCellsAmpFraction[i];
    }
    throw CellOutOfRangeException(i);
  }
 
  [[nodiscard]] bool getIsExotic() const { return mIsExotic; }
  void setIsExotic(bool b) { mIsExotic = b; }
 
  void setClusterTime(float time)
  {
    mTime = time;
  }
 
  [[nodiscard]] float getClusterTime() const
  {
    return mTime;
  }
 
  [[nodiscard]] int getIndMaxInput() const { return mInputIndMax; }
  void setIndMaxInput(const int ind) { mInputIndMax = ind; }
 
  [[nodiscard]] float getCoreEnergy() const { return mCoreEnergy; }
  void setCoreEnergy(float energy) { mCoreEnergy = energy; }
 
  [[nodiscard]] float getFCross() const { return mFCross; }
  void setFCross(float fCross) { mFCross = fCross; }
 
  [[nodiscard]] TLorentzVector getMomentum(std::array<const float, 3> vertexPosition) const;
 
 protected:
  std::vector<int> mLabels; 
 
  int mNCells = 0; 
 
  std::vector<unsigned short> mCellsIndices; //[mNCells]
 
  std::vector<float> mCellsAmpFraction; //[mNCells][0.,1.,16]
 
  math_utils::Point3D<float> mGlobalPos; 
  math_utils::Point3D<float> mLocalPos;  
  float mEnergy = 0;                     
  float mCoreEnergy = 0.;                
  float mDispersion = 0;                 
  float mChi2 = 0;                       
  float mM20 = 0;                        
  float mM02 = 0;                        
 
  float mEmcCpvDistance = 1024; 
 
  float mTrackDx = 1024; 
  float mTrackDz = 1024; 
 
  float mDistToBadChannel = 1024; 
 
  int mID = 0;               
  unsigned char mNExMax = 0; 
 
  float mTime = 0.; 
 
  bool mIsExotic = false; 
  float mFCross = 0.f;    
 
  int mInputIndMax = -1; 
 
  ClassDefNV(AnalysisCluster, 3);
};
 
} // namespace o2::emcal
#endif // ANALYSISCLUSTER_H