DQMHistoModuleBase.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 <framework/core/HistoModule.h>
#include <framework/geometry/B2Vector3.h>
#include <mdst/dataobjects/Track.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <framework/core/ModuleParam.templateDetails.h>
 
#include <TH1F.h>
#include <TH2F.h>
 
namespace Belle2 {
  class DQMHistoModuleBase : public HistoModule {
 
  public:

    DQMHistoModuleBase();

    ~DQMHistoModuleBase();

    virtual void initialize() override;

    virtual void beginRun() override;

    virtual void event() override;

    virtual void defineHisto() override;

    void runningOnHLT() {m_hltDQM = true;};

    virtual TH1F* Create(std::string name, std::string title, int nbinsx, double xlow, double xup, std::string xTitle,
                         std::string yTitle);
    virtual TH2F* Create(std::string name, std::string title, int nbinsx, double xlow, double xup, int nbinsy, double ylow, double yup,
                         std::string xTitle, std::string yTitle, std::string zTitle);

    virtual TH1F** CreateLayers(boost::format nameTemplate, boost::format titleTemplate, int nbinsx, double xlow, double xup,
                                std::string xTitle, std::string yTitle);
    virtual TH2F** CreateLayers(boost::format nameTemplate, boost::format titleTemplate, int nbinsx, double xlow, double xup,
                                int nbinsy, double ylow, double yup, std::string xTitle, std::string yTitle, std::string zTitle);

    virtual TH1F** CreateSensors(boost::format nameTemplate, boost::format titleTemplate, int nbinsx, double xlow, double xup,
                                 std::string xTitle, std::string yTitle);
    virtual TH2F** CreateSensors(boost::format nameTemplate, boost::format titleTemplate, int nbinsx, double xlow, double xup,
                                 int nbinsy, double ylow, double yup, std::string xTitle, std::string yTitle, std::string zTitle);

    virtual void FillTrackIndexes(int iTrack, int iTrackVXD, int iTrackCDC, int iTrackVXDCDC);
    virtual void FillHitNumbers(int nPXD, int nSVD, int nCDC);
    virtual void FillMomentumAngles(const TrackFitResult* tfr);
    virtual void FillMomentumCoordinates(const TrackFitResult* tfr);
    virtual void FillHelixParametersAndCorrelations(const TrackFitResult* tfr);
    virtual void FillTrackFitStatus(const genfit::FitStatus* tfs);
    virtual void FillTRClusterCorrelations(float phi_deg, float phiPrev_deg, float theta_deg, float thetaPrev_deg,
                                           int correlationIndex);
    virtual void FillTRClusterHitmap(float phi_deg, float theta_deg, int layerIndex);
    virtual void FillUBResidualsPXD(const B2Vector3D& residual_um);
    virtual void FillUBResidualsSVD(const B2Vector3D& residual_um);
    virtual void FillHalfShellsPXD(const B2Vector3D& globalResidual_um, bool isNotYang);
    virtual void FillHalfShellsSVD(const B2Vector3D& globalResidual_um, bool isNotMat);
    virtual void FillUB1DResidualsSensor(const B2Vector3D& residual_um, int sensorIndex);
    virtual void FillUB2DResidualsSensor(const B2Vector3D& residual_um, int sensorIndex);
 
  protected:
    static std::string SensorNameDescription(VxdID sensorID);
    static std::string SensorTitleDescription(VxdID sensorID);

    static void ComputeMean(TH1F* output, TH2F* input, bool onX = true);

    void ProcessHistogramParameterChange(const std::string& name, const std::string& parameter, const std::string& value);
    void EditHistogramParameter(TH1* histogram, const std::string& parameter, std::string value);

    virtual void DefineTracks();
    virtual void DefineHits();
    virtual void DefineMomentumAngles();
    virtual void DefineMomentumCoordinates();
    virtual void DefineHelixParametersAndCorrelations();
    virtual void DefineTrackFitStatus();
    virtual void DefineTRClusters();
    virtual void DefineUBResidualsVXD();
    virtual void DefineHalfShellsVXD();
    virtual void Define1DSensors();
    virtual void Define2DSensors();

    std::vector<TH1*> m_histograms;
    bool histogramsDefined = false;
    bool m_hltDQM = false;

    std::vector<std::tuple<std::string, std::string, std::string>> m_histogramParameterChanges;
    std::string m_tracksStoreArrayName;
    std::string m_recoTracksStoreArrayName;

    TH1F* m_PValue = nullptr;
    TH1F* m_Chi2 = nullptr;
    TH1F* m_NDF = nullptr;
    TH1F* m_Chi2NDF = nullptr;
    TH2F* m_UBResidualsPXD = nullptr;
    TH2F* m_UBResidualsSVD = nullptr;
    TH2F** m_UBResidualsSensor = nullptr;
    TH1F* m_UBResidualsPXDU = nullptr;
    TH1F* m_UBResidualsSVDU = nullptr;
    TH1F** m_UBResidualsSensorU = nullptr;
    TH1F* m_UBResidualsPXDV = nullptr;
    TH1F* m_UBResidualsSVDV = nullptr;

    TH1F* m_UBResidualsPXDX_Yin = nullptr;
    TH1F* m_UBResidualsPXDX_Yang = nullptr;
    TH1F* m_UBResidualsSVDX_Pat = nullptr;
    TH1F* m_UBResidualsSVDX_Mat = nullptr;

    TH1F* m_UBResidualsPXDY_Yin = nullptr;
    TH1F* m_UBResidualsPXDY_Yang = nullptr;
    TH1F* m_UBResidualsSVDY_Pat = nullptr;
    TH1F* m_UBResidualsSVDY_Mat = nullptr;

    TH1F* m_UBResidualsPXDZ_Yin = nullptr;
    TH1F* m_UBResidualsPXDZ_Yang = nullptr;
    TH1F* m_UBResidualsSVDZ_Pat = nullptr;
    TH1F* m_UBResidualsSVDZ_Mat = nullptr;

    TH1F** m_UBResidualsSensorV = nullptr;
    TH2F** m_TRClusterHitmap = nullptr;
    TH2F** m_TRClusterCorrelationsPhi = nullptr;
    TH2F** m_TRClusterCorrelationsTheta = nullptr;

    TH1F* m_MomPhi = nullptr;
    TH1F* m_MomTheta = nullptr;
    TH1F* m_MomCosTheta = nullptr;
    TH1F* m_MomX = nullptr;
    TH1F* m_MomY = nullptr;
    TH1F* m_MomZ = nullptr;
    TH1F* m_MomPt = nullptr;
    TH1F* m_Mom = nullptr;
    TH1F* m_D0 = nullptr;
    TH2F* m_PhiD0 = nullptr;
    TH1F* m_Z0 = nullptr;
    TH2F* m_D0Z0 = nullptr;
    TH1F* m_Phi = nullptr;
    TH1F* m_TanLambda = nullptr;
    TH1F* m_Omega = nullptr;

    TH1F* m_HitsPXD = nullptr;
    TH1F* m_HitsSVD = nullptr;
    TH1F* m_HitsCDC = nullptr;
    TH1F* m_Hits = nullptr;
    TH1F* m_TracksVXD = nullptr;
    TH1F* m_TracksCDC = nullptr;
    TH1F* m_TracksVXDCDC = nullptr;
    TH1F* m_Tracks = nullptr;
 
  private:
    inline bool checkVariableForNANOrINF(const double var)
    {
      return std::isnan(var) or std::isinf(var);
    }
  };

}