Cluster.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_PHOS_CLUSTER_H_
#define ALICEO2_PHOS_CLUSTER_H_
#include <vector>
#include <Rtypes.h>
 
namespace o2
{
namespace phos
{
class Geometry;
 
struct CluElement {
  short absId = 0;
  bool isHG = false;
  int label = -1;
  float energy = 0.;
  float time = 0.;
  float localX = 0.;
  float localZ = 0.;
  float fraction = 0.;
  CluElement() = default;
  CluElement(short a, bool hg, float e, float t, float x, float z, int lab, float fr) : absId(a), isHG(hg), label(lab), energy(e), time(t), localX(x), localZ(z), fraction(fr) {}
};
 
class Cluster
{
 
 public:
  Cluster() = default;
  Cluster(const Cluster& clu) = default;
 
  ~Cluster() = default;
 
  bool operator<(const Cluster& other) const;
  bool operator>(const Cluster& other) const;
 
  float getEnergy() const { return mFullEnergy; }
  void setEnergy(float e) { mFullEnergy = e; }
 
  float getCoreEnergy() const { return mCoreEnergy; }
  void setCoreEnergy(float ec) { mCoreEnergy = ec; }
 
  float getDispersion() const { return mDispersion; }
  void setDispersion(float d) { mDispersion = d; }
 
  float getDistanceToBadChannel() const { return mDistToBadChannel; }
  void getElipsAxis(float& lambdaShort, float& lambdaLong) const
  {
    lambdaShort = mLambdaShort;
    lambdaLong = mLambdaLong;
  }
  void setElipsAxis(float lambdaShort, float lambdaLong)
  {
    mLambdaShort = lambdaShort;
    mLambdaLong = lambdaLong;
  }
  void getLocalPosition(float& posX, float& posZ) const
  {
    posX = mLocalPosX;
    posZ = mLocalPosZ;
  }
  void setLocalPosition(float posX, float posZ)
  {
    mLocalPosX = posX;
    mLocalPosZ = posZ;
  }
  int getMultiplicity() const { return mLastCluElement - mFirstCluElement; } // gets the number of digits making this cluster
 
  // 0: was no unfolging, -1: unfolding failed
  void setNExMax(char nmax = 1) { mNExMax = nmax; }
  char getNExMax() const { return mNExMax; }  // Number of maxima found in cluster in unfolding:
                                              // 0: was no unfolging, -1: unfolding failed
  char module() const { return mModule; }     // PHOS module of a current cluster
  void setModule(char mod) { mModule = mod; } // set PHOS module of a current cluster
 
  float getTime() const { return mTime; }
  void setTime(float t) { mTime = t; }
 
  char firedTrigger() const { return mFiredTrigger; }
  void setFiredTrigger(char t) { mFiredTrigger = t; }
 
  void addDigit() { mLastCluElement++; }
 
  uint32_t getFirstCluEl() const { return mFirstCluElement; }
  uint32_t getLastCluEl() const { return mLastCluElement; }
  void setFirstCluEl(uint32_t first) { mFirstCluElement = first; }
  void setLastCluEl(uint32_t last) { mLastCluElement = last; }
 
  // // Binary search implementation
  // std::vector<Digit>::const_iterator BinarySearch(const std::vector<Digit>* container, Digit& element);
 
 protected:
  char mModule = 0;               
  char mNExMax = -1;              
  char mFiredTrigger = 0;         
  uint32_t mFirstCluElement = -1; 
  uint32_t mLastCluElement = -1;  
  float mLocalPosX = 0.;          
  float mLocalPosZ = 0.;          
  float mFullEnergy = 0.;         
  float mCoreEnergy = 0.;         
  float mLambdaLong = 0.;         
  float mLambdaShort = 0.;        
  float mDispersion = 0.;         
  float mTime = 0.;               
  float mDistToBadChannel = 999;  
 
  ClassDefNV(Cluster, 4);
};
} // namespace phos
} // namespace o2
 
#endif