KLMChannelStatusAlgorithm.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/dataobjects/KLMChannelMapValue.h>
#include <klm/dbobjects/KLMChannelStatus.h>
 
/* Basf2 headers. */
#include <calibration/CalibrationAlgorithm.h>
 
namespace Belle2 {

  class KLMChannelStatusAlgorithm : public CalibrationAlgorithm {
 
  public:

    class Results {
 
      friend class KLMChannelStatusAlgorithm;
 
    public:

      Results();

      Results(const Results& results);

      Results& operator=(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() override;

    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(KLMSectorNumber sector,
                         double averageHitsActiveSector);

    void calibrateModule(KLMModuleNumber module);

    bool markHotChannel(KLMChannelNumber channel, unsigned int moduleHits,
                        int activeChannels);

    void calibrateChannel(KLMChannelNumber 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;
 
  };

}