CDCTriggerNeuroDQMOnlineModule.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/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <trg/cdc/dataobjects/CDCTriggerTrack.h>
#include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
#include <trg/cdc/dataobjects/CDCTriggerMLPInput.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <framework/dataobjects/BinnedEventT0.h>
 
#include "TH1F.h"
 
namespace Belle2 {
  class CDCTriggerNeuroDQMOnlineModule : public HistoModule {  // <- derived from HistoModule class
 
  public:
    CDCTriggerNeuroDQMOnlineModule();
    virtual ~CDCTriggerNeuroDQMOnlineModule();
 
 
  private:
 
    struct TSLine {
      const CDCTriggerSegmentHit* hit;
      std::string strline;
      //vector<const CDCTriggerTrack*> relin2dtracks;
      //vector<const CDCTriggerTrack*> relin2dtracks;
      explicit TSLine(const CDCTriggerSegmentHit& h)
      {
        hit = &h;
      }
    };
    typedef std::vector<TSLine> TSLines;
 
    void initialize() override;
    void beginRun() override;
    void event() override;
    void endRun() override;
    void terminate() override;
    void fillHWPlots();
    void fillSimPlots();
    void makeDebugOutput();
    void fillRecoPlots();
 
    void defineHisto() override;
    void condFill(TH1F* histo, float value)
    {
      if (value != 0) {
        histo->Fill(value);
      }
    }
    unsigned getPattern(CDCTriggerTrack* track, std::string hitCollectionName)
    {
      unsigned pattern = 0;
      for (const CDCTriggerSegmentHit& hit : track->getRelationsTo<CDCTriggerSegmentHit>(hitCollectionName)) {
        unsigned sl = hit.getISuperLayer();
        if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
      }
      return pattern;
    }
    bool isValidPattern(unsigned pattern)
    {
      bool valid = false;
      switch (pattern) {
        case 7:
        case 11:
        case 13:
        case 14:
        case 15:
          valid = true;
      }
      return valid;
    }
    std::string padto(std::string s, unsigned l)
    {
      if (s.size() < l) {
        s.insert(s.begin(), l - s.size(), ' ');
      }
      return s;
    }
    std::string padright(std::string s, unsigned l)
    {
      if (s.size() < l) {
        s.insert(s.end(), l - s.size(), ' ');
      }
      return s;
    }
    bool have_relation(const CDCTriggerTrack& track, const CDCTriggerSegmentHit& hit, std::string& arrayname)
    {
      bool related = false;
      for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(arrayname)) {
        if (&ts == &hit) {related = true;}
      }
      return related;
    }
    void sorted_insert(TSLines& lines, TSLine& line, std::string& arrayname, std::string& firstsortarray, std::string& secondsortarray)
    {
      bool inserted = false;
      bool related = false;
      TSLines::iterator it = lines.begin();
      for (const CDCTriggerTrack& track : line.hit->getRelationsFrom<CDCTriggerTrack>(firstsortarray)) {
        if (!inserted) {
          for (TSLines::iterator i = lines.begin(); i < lines.end(); ++i) {
            if (i->hit->getISuperLayer() % 2 != line.hit->getISuperLayer() % 2) {
              continue;
            }
            if (have_relation(track, *(i->hit), arrayname)) {
              it = i;
              related = true;
              if (i->hit->getSegmentID() > line.hit->getSegmentID()) {
                inserted = true;
                break;
              }
            }
          }
        } else { break; }
      }
      if (related) {
        if (!inserted) {++it; }
        lines.insert(it, line);
      } else {
        for (const CDCTriggerTrack& track : line.hit->getRelationsFrom<CDCTriggerTrack>(secondsortarray)) {
          if (!inserted) {
            for (TSLines::iterator i = it; i < lines.end(); ++i) {
              if (i->hit->getISuperLayer() % 2 != line.hit->getISuperLayer() % 2) {
                continue;
              }
              if (have_relation(track, *(i->hit), arrayname)) {
                it = i;
                related = true;
                if (i->hit->getSegmentID() > line.hit->getSegmentID()) {
                  inserted = true;
                  break;
                }
              }
            }
          } else { break; }
        }
        if (related) {
          if (!inserted) {++it; }
          lines.insert(it, line);
        } else {
          lines.push_back(line);
        }
      }
    }
    std::string m_histogramDirectoryName;
 
    std::string m_unpackedNeuroInputAllSegmentHitsName;
    std::string m_unpacked2DTracksName;
    std::string m_unpackedNeuroTracksName;
    std::string m_unpackedNeuroInputVectorName;
    std::string m_unpackedNeuroInput2DTracksName;
    std::string m_unpackedNeuroInputSegmentHitsName;
    std::string m_simNeuroTracksName;
    std::string m_simNeuroInputVectorName;
    std::string m_recoTracksName;
 
    bool m_useRecoTracks;
    bool m_useSimTracks;
 
    // store arrays for direct access
    StoreArray<CDCTriggerSegmentHit> m_unpackedNeuroInputAllSegmentHits;
    StoreArray<CDCTriggerTrack> m_unpacked2DTracks;
    StoreArray<CDCTriggerTrack> m_unpackedNeuroTracks;
    StoreArray<CDCTriggerMLPInput> m_unpackedNeuroInputVector;
    StoreArray<CDCTriggerTrack> m_unpackedNeuroInput2DTracks;
    StoreArray<CDCTriggerSegmentHit> m_unpackedNeuroInputSegmentHits;
    StoreArray<CDCTriggerTrack> m_simNeuroTracks;
    StoreArray<CDCTriggerMLPInput> m_simNeuroInputVector;
    StoreArray<RecoTrack> m_RecoTracks;
    StoreObjPtr<BinnedEventT0> m_eventTime;
 
 
 
 
    TH1F* m_neuroHWOutdzall = nullptr;
    TH1F* m_neuroHWOutdz0 = nullptr;
    TH1F* m_neuroHWOutdz1 = nullptr;
    TH1F* m_neuroHWOutdz2 = nullptr;
    TH1F* m_neuroHWOutdz3 = nullptr;
    TH1F* m_neuroHWSimRecodZ = nullptr;
 
    TH1F* m_neuroHWOutZ = nullptr;
    TH1F* m_recoZ = nullptr;
    TH1F* m_recoZ_related = nullptr;
    TH1F* m_neuroHWOutSTTZ = nullptr;
    TH1F* m_neuroHWOutCosTheta = nullptr;
    TH1F* m_neuroHWOutPhi0 = nullptr;
    TH1F* m_neuroHWOutPt = nullptr;
    TH1F* m_neuroHWOutP = nullptr;
    TH1F* m_neuroHWOutm_time = nullptr;
    TH1F* m_neuroHWValTracksNumber = nullptr;
    TH1F* m_neuroHWSector = nullptr;
    TH1F* m_neuroHWInTSID = nullptr;
    TH1F* m_neuroHWInTSIDSel = nullptr;
    TH1F* m_neuroHWInCDCFE = nullptr;
    TH1F* m_neuroHWInm_time = nullptr;
    TH1F* m_neuroHWIn2DTracksNumber = nullptr;
 
    TH1F* m_neuroHWOutHwSimdZ = nullptr;
    TH1F* m_neuroHWSimZ = nullptr;
    TH1F* m_neuroHWSimCosTheta = nullptr;
    TH1F* m_neuroErrors = nullptr;
    TH1F*  m_neuroHWValTSCountAx = nullptr;
    TH1F*  m_neuroHWValTSCountSt = nullptr;
 
    unsigned m_errcount = 0; // set later
    std::vector<std::string> m_errdict{"Not All HWTrack ATS in 2DInTrack", "|HW-SW| > 1cm", "Delta Input IDs not all 0", "Delta Input Alphas not all 0", "Drifttime Overflow / Scaling Error", "TS only in HW", "TS only in SW", "Multiple ET per Track", "<4 related Axial TS", "<3 related Stereo TS", "Drift Time diff", "Eventcounter"};
 
  };
 
}