KLMChannelStatusAlgorithm.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2020  Belle II Collaboration                              *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Kirill Chilikin                                          *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/dataobjects/KLMChannelMapValue.h>
#include <klm/dbobjects/KLMChannelStatus.h>
 
/* Belle 2 headers. */
#include <calibration/CalibrationAlgorithm.h>
 
namespace Belle2 {
  class KLMChannelStatusAlgorithm : public CalibrationAlgorithm {
 
  public:
 
    class Results {
 
      friend class KLMChannelStatusAlgorithm;
 
    public:
 
      Results();
 
      Results(const Results& results);
 
      ~Results();
 
      KLMChannelStatus& getChannelStatus() const
      {
        return *m_ChannelStatus;
      }
 
      KLMChannelStatus& getModuleStatus() const
      {
        return *m_ModuleStatus;
      }
 
      const KLMChannelMapValue<unsigned int>& getHitMapChannel() const
      {
        return m_HitMapChannel;
      }
 
      const KLMChannelMapValue<unsigned int>& getHitMapModule() const
      {
        return m_HitMapModule;
      }
 
      const KLMChannelMapValue<unsigned int>& getHitMapSector() const
      {
        return m_HitMapSector;
      }
 
      const KLMChannelMapValue<unsigned int>& getHitMapModuleNoHot() const
      {
        return m_HitMapModuleNoHot;
      }
 
      const KLMChannelMapValue<unsigned int>& getHitMapSectorNoHot() const
      {
        return m_HitMapSectorNoHot;
      }
 
      const KLMChannelMapValue<unsigned int>& getModuleActiveChannelMap() const
      {
        return m_ModuleActiveChannelMap;
      }
 
      unsigned int getTotalHitNumber() const
      {
        return m_TotalHitNumber;
      }
 
      unsigned int getHitNumberEKLM() const
      {
        return m_HitNumberEKLM;
      }
 
      unsigned int getHitNumberBKLM() const
      {
        return m_HitNumberBKLM;
      }
 
    private:
 
      KLMChannelStatus* m_ModuleStatus = nullptr;
 
      KLMChannelStatus* m_ChannelStatus = nullptr;
 
      KLMChannelMapValue<unsigned int> m_HitMapChannel;
 
      KLMChannelMapValue<unsigned int> m_HitMapModule;
 
      KLMChannelMapValue<unsigned int> m_HitMapSector;
 
      KLMChannelMapValue<unsigned int> m_HitMapModuleNoHot;
 
      KLMChannelMapValue<unsigned int> m_HitMapSectorNoHot;
 
      KLMChannelMapValue<unsigned int> m_ModuleActiveChannelMap;
 
      unsigned int m_TotalHitNumber = 0;
 
      unsigned int m_HitNumberBKLM = 0;
 
      unsigned int m_HitNumberEKLM = 0;
 
      unsigned int m_HitNumberBKLMNoHot = 0;
 
      unsigned int m_HitNumberEKLMNoHot = 0;
 
    };
 
    KLMChannelStatusAlgorithm();
 
    ~KLMChannelStatusAlgorithm();
 
    CalibrationAlgorithm::EResult calibrate() override;
 
    void setForcedCalibration(bool forcedCalibration)
    {
      m_ForcedCalibration = forcedCalibration;
    }
 
    void setMinimalModuleHitNumber(unsigned int minimalModuleHitNumber)
    {
      m_MinimalModuleHitNumber = minimalModuleHitNumber;
    }
 
    void setMaximalLogSectorHitsRatio(double maximalLogSectorHitsRatio)
    {
      m_MaximalLogSectorHitsRatio = maximalLogSectorHitsRatio;
    }
 
    void setMinimalHitNumberSingleHotChannel(
      unsigned int minimalHitNumberSingleHotChannel)
    {
      m_MinimalHitNumberSingleHotChannel = minimalHitNumberSingleHotChannel;
    }
 
    void setMinimalHitNumberHotChannel(unsigned int minimalHitNumberHotChannel)
    {
      m_MinimalHitNumberHotChannel = minimalHitNumberHotChannel;
    }
 
    void setMinimalHitNumberRatioHotChannel(
      double minimalHitNumberRatioHotChannel)
    {
      m_MinimalHitNumberRatioHotChannel = minimalHitNumberRatioHotChannel;
    }
 
    double getMinimalAverageHitNumber() const
    {
      return m_MinimalAverageHitNumber;
    }
 
    void setMinimalAverageHitNumber(double minimalAverageHitNumber)
    {
      m_MinimalAverageHitNumber = minimalAverageHitNumber;
    }
 
 
    const Results* getResults() const
    {
      return &m_Results;
    }
 
  protected:
 
    void calibrateSector(uint16_t sector, double averageHitsActiveSector);
 
    void calibrateModule(uint16_t module);
 
    bool markHotChannel(uint16_t channel, unsigned int moduleHits,
                        int activeChannels);
 
    void calibrateChannel(uint16_t channel);
 
    bool m_ForcedCalibration = false;
 
    unsigned int m_MinimalModuleHitNumber = 1;
 
    double m_MinimalAverageHitNumber = 25;
 
    double m_MaximalLogSectorHitsRatio = 1;
 
    unsigned int m_MinimalHitNumberSingleHotChannel = 1000;
 
    unsigned int m_MinimalHitNumberHotChannel = 100;
 
    double m_MinimalHitNumberRatioHotChannel = 50;
 
    const KLMElementNumbers* m_ElementNumbers;
 
    Results m_Results;
 
  };
 
}