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