PXDPerformanceVariablesCollectorModule.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
 
#include <calibration/CalibrationCollectorModule.h>
#include <framework/datastore/StoreObjPtr.h>
#include <vxd/geometry/GeoCache.h>
#include <pxd/geometry/SensorInfo.h>
#include <pxd/utilities/PXDPerformanceStructs.h>
#include <pxd/utilities/PXDUtilities.h>
#include <pxd/reconstruction/PXDGainCalibrator.h>
#include <pxd/dbobjects/PXDGainMapPar.h>
#include <pxd/reconstruction/PXDPixelMasker.h>
 
#include <string>
 
namespace Belle2 {
  class PXDPerformanceVariablesCollectorModule : public CalibrationCollectorModule {
 
  public:

    PXDPerformanceVariablesCollectorModule();
    void prepare() override final;
    void collect() override final;
    void startRun() override final;

    void collectDeltaIP();
    void collectGainVariables(const PXD::TrackCluster_t& trackCluster);
    void collectEfficiencyVariables(const PXD::TrackCluster_t& trackCluster);

    int getBinID(const PXD::TrackCluster_t& trackCluster, int& uBin, int& vBin, bool useCluster = false)
    {
 
      // Get PXD::TrackPoint_t
      auto const& tPoint = trackCluster.intersection;
      // Get uBin and vBin from a global point.
      VxdID sensorID = PXD::getVxdIDFromPXDModuleID(trackCluster.cluster.pxdID);
      const PXD::SensorInfo& Info = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
      float posU(0.), posV(0.);
      if (useCluster) {
        posU = trackCluster.cluster.posU;
        posV = trackCluster.cluster.posV;
      } else {
        auto localPoint = Info.pointToLocal(ROOT::Math::XYZVector(tPoint.x, tPoint.y, tPoint.z), true);
        posU = localPoint.X();
        posV = localPoint.Y();
      }
      auto uID = Info.getUCellID(posU);
      auto vID = Info.getVCellID(posV);
      auto iSensor = VXD::GeoCache::getInstance().getGeoTools()->getPXDSensorIndex(sensorID);
      uBin = PXD::PXDGainCalibrator::getInstance().getBinU(sensorID, uID, vID, m_nBinsU);
      vBin = PXD::PXDGainCalibrator::getInstance().getBinV(sensorID, vID, m_nBinsV);
      //assert(uBin < m_nBinsU && vBin < m_nBinsV);
      if (uBin >= m_nBinsU || vBin >= m_nBinsV)
        throw std::out_of_range("uBin or vBin is outside of valid range.");
 
      return iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin;
    }

    bool isSelected(const VxdID& sensorID, const int& uID, const int& vID)
    {
      // Check a pixel matrix around the track point. Skip counting If any pixel is dead/hot.
      // TODO: Using a dedicated cluster flag (under development).
      if (PXD::isCloseToBorder(uID, vID, m_maskedDistance) ||
          PXD::isDefectivePixelClose(uID, vID, m_maskedDistance, sensorID))
        return false;
      return true;
    }
 
  private:
    StoreObjPtr<EventMetaData> m_evtMetaData;

    int m_minClusterCharge;
    int m_minClusterSize;
    int m_maxClusterSize;
    int m_maskedDistance;

    int m_nBinsU;
    int m_nBinsV;
    std::string m_gainName;
    bool m_useClusterPosition;
    bool m_fillChargeRatioHistogram;
    bool m_fillChargeTree;

    bool m_selected4Eff;

    float m_deltaD0oSqrt2;
    float m_deltaZ0oSqrt2;
    int m_signal;
    float m_estimated;
    int m_run;
    int m_exp;
    PXDGainMapPar m_gainMap;

    PXD::Track_t m_track_struct;
    std::string m_PList4GainName = "";
    std::string m_PList4EffName = "";
    std::string m_PList4ResName = "";
 
  };

}