Clusterer.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_CLUSTERER_H
#define ALICEO2_PHOS_CLUSTERER_H
#include "DataFormatsPHOS/Digit.h"
#include "DataFormatsPHOS/Cell.h"
#include "DataFormatsPHOS/Cluster.h"
#include "DataFormatsPHOS/CalibParams.h"
#include "DataFormatsPHOS/BadChannelsMap.h"
#include "DataFormatsPHOS/MCLabel.h"
#include "DataFormatsPHOS/TriggerRecord.h"
#include "SimulationDataFormat/MCTruthContainer.h"
#include "PHOSBase/Geometry.h"
 
namespace o2
{
namespace phos
{
 
class Clusterer
{
 public:
  Clusterer() = default;
  ~Clusterer() = default;
 
  void initialize();
  void process(gsl::span<const Digit> digits, gsl::span<const TriggerRecord> dtr,
               const o2::dataformats::MCTruthContainer<MCLabel>* dmc,
               std::vector<Cluster>& clusters, std::vector<CluElement>& cluel, std::vector<TriggerRecord>& rigRec,
               o2::dataformats::MCTruthContainer<MCLabel>& cluMC);
  void processCells(gsl::span<const Cell> digits, gsl::span<const TriggerRecord> dtr,
                    const o2::dataformats::MCTruthContainer<MCLabel>* dmc,
                    std::vector<Cluster>& clusters, std::vector<CluElement>& cluel, std::vector<TriggerRecord>& rigRec,
                    o2::dataformats::MCTruthContainer<MCLabel>& cluMC);
 
  void makeClusters(std::vector<Cluster>& clusters, std::vector<o2::phos::CluElement>& cluel);
 
  void setBadMap(const o2::phos::BadChannelsMap* m) { mBadMap = m; }
  void setCalibration(const o2::phos::CalibParams* c) { mCalibParams = c; }
  void setL1phase(int phase)
  {
    mL1phase = phase;
    mSkipL1phase = false;
  }
 
 protected:
  // Calibrate energy
  inline float calibrate(float amp, short absId, bool isHighGain)
  {
    if (isHighGain) {
      return amp * mCalibParams->getGain(absId);
    } else {
      return amp * mCalibParams->getGain(absId) * mCalibParams->getHGLGRatio(absId);
    }
  }
  // Calibrate time
  inline float calibrateT(float time, short absId, bool isHighGain, int bc)
  {
    // L1phase correction
    float shift = 0;
    if (!mSkipL1phase) {
      char relid[3];
      o2::phos::Geometry::absToRelNumbering(absId, relid);
      int ddl = (relid[0] - 1) * 4 + (relid[1] - 1) / 16 - 2;
      int l1 = (mL1phase >> (ddl * 2)) & 3; // extract 2 bits corresponding to this ddl
      l1 = bc % 4 - l1;
      if (l1 < 0) {
        l1 += 4;
      }
      shift = l1 * 25.e-9;
    }
    // Calibrate time
    if (isHighGain) {
      return time - mCalibParams->getHGTimeCalib(absId) - shift;
    } else {
      return time - mCalibParams->getLGTimeCalib(absId) - shift;
    }
  }
  // Test Bad map
  inline bool isBadChannel(short absId) { return (!mBadMap->isChannelGood(absId)); }
 
  char getNumberOfLocalMax(Cluster& clu, std::vector<CluElement>& cluel);
  void evalAll(Cluster& clu, std::vector<CluElement>& cluel) const;
  void evalLabels(std::vector<Cluster>& clusters, std::vector<CluElement>& cluel,
                  const o2::dataformats::MCTruthContainer<MCLabel>* dmc,
                  o2::dataformats::MCTruthContainer<MCLabel>& cluMC);
 
  double showerShape(double r2, double& deriv); // Parameterization of EM shower
 
  void makeUnfolding(Cluster& clu, std::vector<Cluster>& clusters, std::vector<o2::phos::CluElement>& cluel); // unfold cluster with few local maxima
  void unfoldOneCluster(Cluster& iniClu, char nMax, std::vector<Cluster>& clusters, std::vector<CluElement>& cluelements);
 
 protected:
  static constexpr short NLOCMAX = 30; // Maximal number of local maxima in cluster
  bool mProcessMC = false;
  int miCellLabel = 0;
  bool mFullCluOutput = false;               
  bool mSkipL1phase = true;                  
  int mL1phase = 0;                          
  Geometry* mPHOSGeom = nullptr;             
  const CalibParams* mCalibParams = nullptr; 
  const BadChannelsMap* mBadMap = nullptr;   
 
  std::vector<CluElement> mCluEl; 
  std::vector<Digit> mTrigger;    
  int mFirstElememtInEvent;       
  int mLastElementInEvent;        
 
  std::vector<float> mProp;             
  std::array<float, NLOCMAX> mxMax;     
  std::array<float, NLOCMAX> mzMax;     
  std::array<float, NLOCMAX> meMax;     
  std::array<float, NLOCMAX> mxMaxPrev; 
  std::array<float, NLOCMAX> mzMaxPrev; 
  std::array<float, NLOCMAX> mdx;       
  std::array<float, NLOCMAX> mdz;       
  std::array<float, NLOCMAX> mdxprev;   
  std::array<float, NLOCMAX> mdzprev;   
  std::array<double, NLOCMAX> mA;       
  std::array<double, NLOCMAX> mxB;      
  std::array<double, NLOCMAX> mzB;      
  std::array<double, NLOCMAX> mfijx;    
  std::array<double, NLOCMAX> mfijz;    
  std::array<double, NLOCMAX> mfijr;    
  std::array<double, NLOCMAX> mfij;     
  std::vector<bool> mIsLocalMax;        
  std::array<int, NLOCMAX> mMaxAt;      
};
} // namespace phos
} // namespace o2
 
#endif